def print_galaxy_result(self):
res=self.gal_fitter.get_result()
if 'pars' in res:
print_pars(res['pars'], front=' gal_pars: ')
if 'pars_err' in res:
print_pars(res['pars_err'],front=' gal_perr: ')
def print_galaxy_result(self):
res = self.gal_fitter.get_result()
if 'pars' in res:
print_pars(res['pars'], front=' gal_pars: ')
if 'pars_err' in res:
print_pars(res['pars_err'], front=' gal_perr: ')
def _fit_simple_lm(self, obs, model, guesser):
from ngmix.fitting import LMSimple
max_pars = self['max_pars']
prior = self['search_prior']
#if obs.has_psf():
# print("psf _data:",obs.psf.gmix._data)
# print("psf copy _data:",obs.psf.gmix.copy()._data)
fitter = LMSimple(obs,
model,
prior=prior,
use_logpars=self['use_logpars'],
lm_pars=max_pars['lm_pars'])
for i in xrange(max_pars['ntry']):
guess = guesser(prior=prior)
print_pars(guess, front=' lm_guess: ')
fitter.run_max(guess)
res = fitter.get_result()
if res['flags'] == 0:
break
return fitter
def _print_galaxy_res(self, fitter):
res=fitter.get_result()
if 'nfev' in res:
front= " max pars: "
efront=" max err: "
else:
front= " pars: "
efront=" err: "
if 'pars' in res:
print_pars(res['pars'], front=front)
if 'pars_err' in res:
print_pars(res['pars_err'], front=efront)
if 'g_sens' in res:
print(" g_sens: [%.2f, %.2f]" % (res['g_sens'][0],res['g_sens'][1]))
if 'arate' in res:
mess=" s/n: %.1f arate: %.2f tau: %.1f chi2per: %.2f"
tup = (res['s2n_w'],res['arate'],res['tau'],res['chi2per'])
mess=mess % tup
print(mess)
elif 'efficiency' in res:
mess=" s/n: %.1f neff: %.1f efficiency: %.2f chi2per: %.2f"
tup = (res['s2n_w'],res['neff'],res['efficiency'],res['chi2per'])
mess=mess % tup
print(mess)
elif 's2n_w' in res:
mess=" s/n: %.1f" % res['s2n_w']
if 'nfev' in res:
mess="%s nfev: %d" % (mess,res['nfev'])
print(mess)
else:
print(" NO COV PRESENT")
def _fit_simple_max(self, obs, model, guesser):
from ngmix.fitting import MaxSimple
max_pars = self['max_pars']
if max_pars['method'] == 'lm':
return self._fit_simple_lm(obs, model, guesser)
prior = self['search_prior']
#print("search prior:",prior)
fitter = MaxSimple(obs,
model,
prior=prior,
use_logpars=self['use_logpars'],
**max_pars)
for i in xrange(max_pars['ntry']):
guess = guesser(prior=prior)
print_pars(guess, front=' max_guess: ')
fitter.run_max(guess, **max_pars)
res = fitter.get_result()
if res['flags'] == 0:
break
return fitter
def _fit_simple_lm(self, obs, model, guesser):
from ngmix.fitting import LMSimple
max_pars=self['max_pars']
prior=self['search_prior']
#if obs.has_psf():
# print("psf _data:",obs.psf.gmix._data)
# print("psf copy _data:",obs.psf.gmix.copy()._data)
fitter=LMSimple(obs,
model,
prior=prior,
use_logpars=self['use_logpars'],
lm_pars=max_pars['lm_pars'])
for i in xrange(max_pars['ntry']):
guess=guesser(prior=prior)
print_pars(guess,front=' lm_guess: ')
fitter.run_max(guess)
res=fitter.get_result()
if res['flags']==0:
break
return fitter
def _fit_simple_max(self, obs, model, guesser):
from ngmix.fitting import MaxSimple
max_pars=self['max_pars']
if max_pars['method']=='lm':
return self._fit_simple_lm(obs, model, guesser)
prior=self['search_prior']
#print("search prior:",prior)
fitter=MaxSimple(obs,
model,
prior=prior,
use_logpars=self['use_logpars'],
**max_pars)
for i in xrange(max_pars['ntry']):
guess=guesser(prior=prior)
print_pars(guess,front=' max_guess: ')
fitter.run_max(guess, **max_pars)
res=fitter.get_result()
if res['flags']==0:
break
return fitter
def _fit_psf_max(self, obs):
from ngmix.fitting import MaxSimple,LMSimple
assert self['psf_model'] in ["turb","gauss"],"gauss,turb only for now"
max_pars=self['psf_max_pars']
if self['psf_method']=='Nelder-Mead':
fitter=MaxSimple(obs, self['psf_model'], method=self['psf_method'])
else:
fitter=LMSimple(obs, self['psf_model'], lm_pars=max_pars)
Tguess=2*self['psf_sigma_guess']**2
Fguess=obs.image.sum()
guess0=array([0.0, 0.0, 0.0, 0.0, Tguess, Fguess])
for i in xrange(self['psf_ntry']):
guess=guess0.copy()
guess[0:0+2] += 0.01*srandu(2)
guess[2:2+2] += 0.1*srandu(2)
guess[4] *= (1.0 + 0.1*srandu())
guess[5] *= (1.0 + 0.1*srandu())
print_pars(guess,front=' guess: ')
if self['psf_method']=='lm':
fitter.run_max(guess)
else:
fitter.run_max(guess, **max_pars)
res=fitter.get_result()
if res['flags']==0:
print(" max_nfev:",res['nfev'])
break
return fitter
def _print_galaxy_res(self, model):
from ngmix.fitting import print_pars
print(" model:",model)
res=self.res[model]['res']
rres=self.res[model]['round_res']
print_pars(res['pars'], front=" pars: ")
print_pars(res['pars_err'], front=" err: ")
mess=' s2n: %.1f s2n_r: %.1f chi2per: %.2f'
mess=mess % (res['s2n_w'], rres['s2n_r'], res['chi2per'])
print(mess)
def print_some_stats(self):
"""
Print some stats from the fitter result
"""
from ngmix.fitting import print_pars
res=self.res
print_pars(res['pars'],front=' pars: ')
print_pars(res['pars_err'],front=' perr: ')
T_s2n=res['pars'][4]/res['pars_err'][4]
flux_s2n=res['pars'][5]/res['pars_err'][5]
print(' T_s2n: %g flux_s2n: %g' % (T_s2n, flux_s2n))
mess=' arate: %(arate)g chi2per: %(chi2per)g'
mess = mess % res
print(mess)
def _fit_psf_max(self, obs):
from ngmix.fitting import MaxSimple, LMSimple
assert self['psf_model'] in ["turb",
"gauss"], "gauss,turb only for now"
max_pars = self['psf_max_pars']
if self['psf_method'] == 'Nelder-Mead':
fitter = MaxSimple(obs,
self['psf_model'],
method=self['psf_method'])
else:
fitter = LMSimple(obs, self['psf_model'], lm_pars=max_pars)
Tguess = 2 * self['psf_sigma_guess']**2
Fguess = obs.image.sum()
guess0 = array([0.0, 0.0, 0.0, 0.0, Tguess, Fguess])
for i in xrange(self['psf_ntry']):
guess = guess0.copy()
guess[0:0 + 2] += 0.01 * srandu(2)
guess[2:2 + 2] += 0.1 * srandu(2)
guess[4] *= (1.0 + 0.1 * srandu())
guess[5] *= (1.0 + 0.1 * srandu())
print_pars(guess, front=' guess: ')
if self['psf_method'] == 'lm':
fitter.run_max(guess)
else:
fitter.run_max(guess, **max_pars)
res = fitter.get_result()
if res['flags'] == 0:
print(" max_nfev:", res['nfev'])
break
return fitter
def copy_psf_result(self):
"""
copy some subset of the psf parameters
"""
ppars = self['psf_pars']
data = self.data
fitter = self.psf_fitter
res = fitter.get_result()
data['psf_flags'][self.dindex] = res['flags']
if 'nfev' in res:
data['psf_nfev'][self.dindex] = res['nfev']
elif 'numiter' in res:
data['psf_nfev'][self.dindex] = res['numiter']
if res['flags'] != 0:
return
psf_gmix = fitter.get_gmix()
g1, g2, T = psf_gmix.get_g1g2T()
print(" psf_id: %d psf_fwhm: %.3f g: %.3g %.3g" %
(self['psf_id'], sqrt(T / 2) * 2.35, g1, g2))
if 'em' in ppars['model']:
print(" niter: %d fdiff: %g" % (res['numiter'], res['fdiff']))
else:
print_pars(res['pars'], front=' psf_pars: ')
print_pars(res['pars_err'], front=' psf_perr: ')
data['psf_g'][self.dindex, 0] = g1
data['psf_g'][self.dindex, 1] = g2
data['psf_T'][self.dindex] = T
def _print_galaxy_res(self, fitter):
res = fitter.get_result()
if 'nfev' in res:
front = " max pars: "
efront = " max err: "
else:
front = " pars: "
efront = " err: "
if 'pars' in res:
print_pars(res['pars'], front=front)
if 'pars_err' in res:
print_pars(res['pars_err'], front=efront)
if 'g_sens' in res:
print(" g_sens: [%.2f, %.2f]" %
(res['g_sens'][0], res['g_sens'][1]))
if 'arate' in res:
mess = " s/n: %.1f arate: %.2f tau: %.1f chi2per: %.2f"
tup = (res['s2n_w'], res['arate'], res['tau'], res['chi2per'])
mess = mess % tup
print(mess)
elif 'efficiency' in res:
mess = " s/n: %.1f neff: %.1f efficiency: %.2f chi2per: %.2f"
tup = (res['s2n_w'], res['neff'], res['efficiency'],
res['chi2per'])
mess = mess % tup
print(mess)
elif 's2n_w' in res:
mess = " s/n: %.1f" % res['s2n_w']
if 'nfev' in res:
mess = "%s nfev: %d" % (mess, res['nfev'])
print(mess)
else:
print(" NO COV PRESENT")
def copy_psf_result(self):
"""
copy some subset of the psf parameters
"""
ppars=self['psf_pars']
data=self.data
fitter=self.psf_fitter
res=fitter.get_result()
data['psf_flags'][self.dindex] = res['flags']
if 'nfev' in res:
data['psf_nfev'][self.dindex] = res['nfev']
elif 'numiter' in res:
data['psf_nfev'][self.dindex] = res['numiter']
if res['flags'] != 0:
return
psf_gmix=fitter.get_gmix()
g1,g2,T=psf_gmix.get_g1g2T()
print(" psf_id: %d psf_fwhm: %.3f g: %.3g %.3g" % (self['psf_id'],sqrt(T/2)*2.35,g1,g2) )
if 'em' in ppars['model']:
print(" niter: %d fdiff: %g" % (res['numiter'],res['fdiff']))
else:
print_pars(res['pars'], front=' psf_pars: ')
print_pars(res['pars_err'],front=' psf_perr: ')
data['psf_g'][self.dindex, 0] = g1
data['psf_g'][self.dindex, 1] = g2
data['psf_T'][self.dindex] = T
def fit_exp(*, rmag, conc, show=False, output=None):
"""
get the amplitude of the stellar locus assuming a
power law distribution A (mag - 13.5)**1.5 The data are binned
and clipped, and sent to the calculate_amp function.
Parameters
----------
rmag: array
psf magnitude, should be r band
conc: array
concentration parameters for stars
show: bool
If True, show a plot
output: string, optional
If sent, write a plot file with that name
Returns
-------
amp, amp_err: float, float
Amplitude and uncertainty
"""
w, = np.where(between(rmag, MAGMIN, MAGMAX) & between(conc, CMIN, CMAX))
hd = eu.stat.histogram(
rmag[w],
min=MAGMIN,
max=MAGMAX,
nbin=NBIN,
more=True,
)
num = hd['hist']
num_err = np.sqrt(num)
guess = [1000, 18, 4, num[:4].mean()]
res = fit_exp_binned(hd['center'], num, num_err, guess)
print_pars(res['pars'], front='pars: ')
print_pars(res['pars_err'], front='pars: ')
if res['flags'] != 0:
raise RuntimeError('fit failed')
if show or output is not None:
import hickory
# alpha = 0.5
plt = hickory.Table(2, 1, figsize=(8, 7))
plt[0].plot(
rmag,
conc,
marker='.',
alpha=0.5,
)
plt[0].plot(
rmag[w],
conc[w],
marker='.',
markeredgecolor='black',
alpha=0.5,
)
plt[0].set(
xlim=(MAGMIN - 0.5, MAGMAX + 0.5),
ylim=(-0.0005, CMAX),
)
plt[0].set(
xlabel='psf mag r',
ylabel='conc',
)
plt[1].errorbar(
hd['center'],
num,
yerr=num_err,
)
predicted = exp_func(res['pars'], hd['center'])
eu.misc.colprint(num,
predicted,
num_err,
format='%20s',
names=['num', 'pred', 'num_err'])
plt[1].curve(hd['center'], predicted)
xvals = np.linspace(13.9, MAGMAX + 0.5)
plt[1].curve(
xvals,
exp_func(res['pars'], xvals),
)
plt[1].set(
xlabel='psf mag r',
ylabel='Number',
xlim=(MAGMIN - 0.5, MAGMAX + 0.5),
yscale='log',
# xlim=(13.5, MAGMAX+0.5),
)
if show:
plt.show()
if output is not None:
print('writing:', output)
plt.savefig(output)
return res['pars']
def get_Ts2n_r_sim(self, mbo, model, pars_round_linear):
"""
input round version of observations
"""
from ngmix.fitting import print_pars
import covmatrix
pars_round=pars_round_linear.copy()
if self['use_logpars']:
pars_round[4:] = log(pars_round[4:])
else:
Tround = pars_round[4]
#print_pars(pars_round, front=" sim Ts2n from pars:")
guess=zeros(pars_round.size-2)
Ts2n=-9999.0
flags=0
prior=self.priors[model]
prior_round=self.priors_round[model]
fitter=ngmix.fitting.LMSimpleRound(mbo, model,
prior=prior_round,
use_logpars=self['use_logpars'])
if self['use_logpars']:
scaling='log'
else:
scaling='linear'
# we set the centers to the exact fit position
# in the get_round_obs method
pars_round[2:2+2] = 0.0
widths=pars_round*0 + 0.10
guesser=FromFullParsGuesser(pars_round, pars_round*0,
scaling=scaling,
widths=widths)
# first guess is truth
guess[0:0+2] = pars_round[0:0+2]
guess[2:] = pars_round[4:]
for i in xrange(self.Ts2n_ntry):
print_pars(guess, front=" guess:")
covold=None
fitter.go(guess)
res=fitter.get_result()
if res['flags']==0:
# try to replace cov
try:
# if the replacement cov fails and this is the last iter,
# we still at least get the LM cov
# otherwise try again
cov=covmatrix.calc_cov(fitter.calc_lnprob, res['pars'], 1.0e-3)
if cov[2,2] > 0:
res['pars_cov']=cov
break
except LinAlgError:
print(" caught linalg")
if i==(self.Ts2n_ntry-1):
print(" using LM cov")
guess0 = guesser(prior=prior)
guess[0:0+2] = guess0[0:0+2]
guess[2:] = guess0[4:]
if res['flags'] != 0:
print(" failure: fit round Ts2n after",i+1,"tries")
flags = TS2N_FAIL
else:
print(" Ts2n ntries:",i+1)
cov=res['pars_cov']
if self['use_logpars']:
Ts2n = sqrt(1.0/cov[2,2])
else:
err=sqrt(cov[2,2])
#print(" Terr:",err)
Ts2n = Tround/err
return Ts2n, flags
