def _convert_dobs_to_obs(self, dobs):
"""
convert a Survey object dobs to an ngmix Observation
"""
j = ngmix.DiagonalJacobian(
row=0,
col=0,
scale=dobs.pixel_scale,
)
im=dobs.image.array
#print('mean sky level:',dobs.mean_sky_level )
#print('sqrt(mean sky level):',np.sqrt(dobs.mean_sky_level ))
noise = np.sqrt( dobs.mean_sky_level )
weight = im*0 + 1.0/noise**2
#psf_im=dobs.psf_image.array.copy()
psf_im = dobs.psf_model.drawImage(
nx=48,
ny=48,
scale=dobs.pixel_scale,
).array
psf_im *= 1.0/psf_im.sum()
pnoise = psf_im.max()/400.0
psf_s2n = np.sqrt( (psf_im**2).sum())/pnoise
logger.debug(' psf s2n: %f' % psf_s2n)
psf_im += self.rng.normal(scale=pnoise, size=psf_im.shape)
psf_weight = psf_im*0 + 1.0/pnoise**2
#import images
#images.multiview(psf_im,title='psf')
#stop
psf_cen = (np.array(psf_im.shape)-1.0)/2.0
psf_j = ngmix.DiagonalJacobian(
row=psf_cen[0],
col=psf_cen[1],
scale=dobs.pixel_scale,
)
psf_obs=ngmix.Observation(
psf_im,
weight=psf_weight,
jacobian=psf_j,
)
return ngmix.Observation(
im,
weight=weight,
jacobian=j,
psf=psf_obs,
)
def make_coadd_obs(mbobs, ignore_zero_weight=True):
"""
perform a simple coadd assuming the images all already align
This is used for combining the coadds from multiple bands
Parameters
----------
mbobs: ngmix.MultiBandObsList
An ngmix multi band observation list to be coadded. The
images must align perfectly and have the same wcs
"""
weights = np.array([obslist[0].weight.max() for obslist in mbobs])
wsum = weights.sum()
nweights = weights / wsum
coadd_image = mbobs[0][0].image.copy()
coadd_image[:, :] = 0.0
coadd_weight = coadd_image.copy()
coadd_weight[:, :] = wsum
coadd_psf = mbobs[0][0].psf.image.copy()
coadd_psf[:, :] = 0
coadd_psf_weight = mbobs[0][0].psf.weight.copy() * 3 # not quite right
for i, obslist in enumerate(mbobs):
obs = obslist[0]
wbad = np.where(obs.weight <= 0.0)
if wbad[0].size > 0:
coadd_weight[wbad] = 0.0
coadd_image += obs.image * nweights[i]
coadd_psf += obs.psf.image * nweights[i]
psf_obs = ngmix.Observation(
coadd_psf,
weight=coadd_psf_weight,
jacobian=mbobs[0][0].psf.jacobian,
)
obs = ngmix.Observation(
coadd_image,
weight=coadd_weight,
jacobian=mbobs[0][0].jacobian,
psf=psf_obs,
ignore_zero_weight=ignore_zero_weight,
)
# import images
# images.view(coadd_weight, title='weight')
return obs
def _get_obs(rng, set_noise_image=False, noise=1.0e-6):
psf_noise = 1.0e-6
scale = 0.263
psf_fwhm = 0.9
gal_fwhm = 0.7
psf = galsim.Gaussian(fwhm=psf_fwhm)
obj0 = galsim.Gaussian(fwhm=gal_fwhm)
obj = galsim.Convolve(psf, obj0)
psf_im = psf.drawImage(scale=scale).array
im = obj.drawImage(scale=scale).array
psf_im += rng.normal(scale=psf_noise, size=psf_im.shape)
im += rng.normal(scale=noise, size=im.shape)
cen = (np.array(im.shape)-1.0)/2.0
psf_cen = (np.array(psf_im.shape)-1.0)/2.0
j = ngmix.DiagonalJacobian(row=cen[0], col=cen[1], scale=scale)
pj = ngmix.DiagonalJacobian(row=psf_cen[0], col=psf_cen[1], scale=scale)
wt = im*0 + 1.0/noise**2
psf_wt = psf_im*0 + 1.0/psf_noise**2
psf_obs = ngmix.Observation(
psf_im,
weight=psf_wt,
jacobian=pj,
)
if set_noise_image:
nim = rng.normal(scale=noise, size=im.shape)
else:
nim = None
bmask = np.zeros(im.shape, dtype='i2')
obs = ngmix.Observation(
im,
weight=wt,
bmask=bmask,
noise=nim,
jacobian=j,
psf=psf_obs,
)
return obs
def _get_mof_obs(self):
im, psf_im, coords, dims, dx1, dy1, noises = self.sim()
bg_rms = self.sim['Image']['Bgrms'] / np.sqrt(len(im))
bg_rms_psf = self.sim['Psf']['Bgrms_psf']
psf_ccen = (np.array(psf_im.shape) - 1.0) / 2.0
psf_jacob = ngmix.UnitJacobian(
row=psf_ccen[0],
col=psf_ccen[1],
)
psf_weight = psf_im * 0 + 1.0 / bg_rms_psf**2
psf_obs = ngmix.Observation(
psf_im,
weight=psf_weight,
jacobian=psf_jacob,
)
psf_gmix = self._fit_psf_admom(psf_obs)
psf_obs.set_gmix(psf_gmix)
mb = MultiBandObsList()
for i in range(len(im)):
if self.show:
import images
tim = im[i] / im[i].max()
tim = np.log10(tim - tim.min() + 1.0)
images.view(tim)
if 'q' == input('hit a key: (q to quit) '):
stop
weight = im[i] * 0 + 1.0 / bg_rms**2
jacobian = ngmix.UnitJacobian(
row=0,
col=0,
)
obs = ngmix.Observation(
im[i],
weight=weight,
jacobian=jacobian,
psf=psf_obs,
)
obs.noise = noises[i]
olist = ObsList()
olist.append(obs)
mb.append(olist)
return mb, coords
def observation(image,sigma,row,col,psf_sigma,psf_im):
# sigma is the standard deviation of the noise
weight = image*0 + 1.0/sigma**2
# row,col are the center of the object in the model
# image, so we need to figure that out somehow
jacob = ngmix.UnitJacobian(row=row, col=col)
psf_weight = psf_im*0 + 1.0/psf_sigma**2
# psf should be centered
cen = [(np.array(psf_im.shape[0]) - 1.0)/2.0,(np.array(psf_im.shape[1]) - 1.0)/2.0]
psf_jacob = ngmix.UnitJacobian(row=cen[0], col=cen[1])
psf_obs = ngmix.Observation(psf_im, weight=psf_weight, jacobian=psf_jacob)
obs = ngmix.Observation(image,weight=weight,jacobian=jacob,psf=psf_obs)
return obs
def _get_ngmix_obs(self, gal_img, psf_img, psf_pars=[0.0, 0.0, -0.01, 0.01, 0.15, 1.0], fit_psf=True):
"""
"""
eps=0.01
lm_pars={'maxfev': 2000,
'xtol': 5.0e-5,
'ftol': 5.0e-5}
img_shape = gal_img.shape
# Jacobian
gal_jacob=ngmix.DiagonalJacobian(scale=self._pixel_scale, x=int((img_shape[0]-1)/2.), y=int((img_shape[1]-1)/2.))
psf_jacob=ngmix.DiagonalJacobian(scale=self._pixel_scale, x=int((img_shape[0]-1)/2.), y=int((img_shape[1]-1)/2.))
# PSF fittitng
psf_noise = np.sqrt(np.sum(psf_img**2)) / 500
psf_weight = np.ones_like(psf_img) / psf_noise**2
psf_obs=ngmix.Observation(psf_img, weight=psf_weight, jacobian=psf_jacob)
if fit_psf:
pfitter=ngmix.fitting.LMSimple(psf_obs,'gauss',lm_pars=lm_pars)
guess=np.array(psf_pars)
guess[0] += urand(low=-eps,high=eps)
guess[1] += urand(low=-eps,high=eps)
guess[2] += urand(low=-eps, high=eps)
guess[3] += urand(low=-eps, high=eps)
guess[4] *= (1.0 + urand(low=-eps, high=eps))
guess[5] *= (1.0 + urand(low=-eps, high=eps))
pfitter.go(guess)
# print(np.abs((pfitter.get_result()['g']-np.array([-0.01, 0.01]))/np.array([-0.01, 0.01])))
psf_gmix_fit = pfitter.get_gmix()
psf_obs.set_gmix(psf_gmix_fit)
# Gal fitting
# Get noise level direclty from the image
sigma_noise = self.mad(gal_img)
noise = np.random.normal(size=img_shape) * sigma_noise
weight = np.ones_like(gal_img) * 1/sigma_noise**2.
obs = ngmix.Observation(gal_img, weight=weight, noise=noise, jacobian=gal_jacob, psf=psf_obs)
return obs
def _get_mini_model(self):
im, psf_im, coords, dims, dx1, dy1, noise = Simulation.__call__(self)
bg_rms = self['Image']['Bgrms']
mode = self['Mode']
allobs = []
bg_rms_psf = self['Psf']['Bgrms_psf']
allconf = yaml.load(
open('/astro/u/esheldon/git/nsim/config/run-nbr01-mcal-02.yaml'))
config = allconf['mof']
config['psf_pars'] = {'model': 'gauss', 'ntry': 2}
for coord in coords:
row, col = coord
obs = observation(im, bg_rms, row, col, bg_rms_psf, psf_im)
this_jacob = obs.jacobian.copy()
this_jacob.set_cen(row=row, col=col)
this_obs = ngmix.Observation(
obs.image.copy(),
weight=obs.weight.copy(),
jacobian=this_jacob,
psf=obs.psf,
)
allobs.append(this_obs)
mm = minimof.MiniMOF(config, allobs, rng=rng)
mm.go()
res = mm.get_result()
if not res['converged']:
output['flags'][j] = 2
else:
obs = mm.get_corrected_obs(0)
return obs, noise
def _make_obs(self):
mbobs = ngmix.MultiBandObsList()
for im in self.imlist:
jacobian = ngmix.DiagonalJacobian(row=0,
col=0,
scale=self['pixel_scale'])
if self['coadd']:
wt = np.zeros(im.shape) + 1.0 / self['coadd_noise_sigma']**2
else:
wt = np.zeros(im.shape) + 1.0 / self['noise_sigma']**2
obs = ngmix.Observation(
im,
weight=wt,
jacobian=jacobian,
psf=self.get_psf_obs(),
)
olist = ngmix.ObsList()
olist.append(obs)
mbobs.append(olist)
self.obs = mbobs
def get_psf_obs(self):
kw = {'scale': self['pixel_scale']}
dims = self.get('psf_dims', None)
if dims is not None:
kw['nx'], kw['ny'] = dims[1], dims[0]
psf_im = self.psf.drawImage(**kw).array
dims = np.array(psf_im.shape)
pcen = (dims - 1.0) / 2.0
pjac = ngmix.DiagonalJacobian(row=pcen[0],
col=pcen[1],
scale=self['pixel_scale'])
psf_im += self.rng.normal(
scale=self['psf']['noise_sigma'],
size=dims,
)
psf_wt = np.zeros(dims) + 1.0 / self['psf']['noise_sigma']**2
return ngmix.Observation(
psf_im,
weight=psf_wt,
jacobian=pjac,
)
def _set_psf(self):
import galsim
self.psf = galsim.Gaussian(fwhm=0.9)
kw = {'scale': self['pixel_scale']}
dims = self.get('psf_dims', None)
if dims is not None:
kw['nx'], kw['ny'] = dims[1], dims[0]
self.psf_im = self.psf.drawImage(**kw).array
dims = np.array(self.psf_im.shape)
pcen = (dims - 1.0) / 2.0
pjac = ngmix.DiagonalJacobian(row=pcen[0],
col=pcen[1],
scale=self['pixel_scale'])
self.psf_im += self.rng.normal(
scale=self['psf_noise_sigma'],
size=dims,
)
psf_wt = np.zeros(dims) + 1.0 / self['psf_noise_sigma']**2
self.psf_obs = ngmix.Observation(
self.psf_im,
weight=psf_wt,
jacobian=pjac,
)
psf_gmix = self._fit_psf_admom(self.psf_obs)
self.psf_obs.set_gmix(psf_gmix)
def get_psf_obs(self, *, x, y, band):
"""Get an ngmix Observation of the PSF at a position.
Parameters
----------
x : float
The column of the PSF.
y : float
The row of the PSF.
band : int
The index of the desired band.
Returns
-------
psf_obs : ngmix.Observation
An Observation of the PSF.
"""
psf_images, psf_wcs, noises, _, _ = self._render_psf_image(
x=x, y=y)
weight = np.zeros_like(psf_images[band]) + 1.0/noises[band]**2
cen = (np.array(psf_images[band].shape) - 1.0)/2.0
j = ngmix.jacobian.Jacobian(
row=cen[0], col=cen[1], wcs=psf_wcs)
psf_obs = ngmix.Observation(
psf_images[band],
weight=weight,
jacobian=j)
return psf_obs
def __call__(self):
"""
get a simulated ngmix.MultiBandObsList
"""
iconf = self['image']
band_images, band_weights, obj_data = self._get_noisy_images()
jacobian = ngmix.DiagonalJacobian(
row=0,
col=0,
scale=iconf['pixel_scale'],
)
mbobs = ngmix.MultiBandObsList()
for image, weight in zip(band_images, band_weights):
obs = ngmix.Observation(
image,
weight=weight,
jacobian=jacobian,
psf=self.get_psf_obs(),
ignore_zero_weight=False,
)
obslist = ngmix.ObsList()
obslist.append(obs)
mbobs.append(obslist)
obj_data_with_cen = self._set_centers(obs, obj_data)
mbobs.meta['obj_data'] = obj_data_with_cen
return mbobs
def _do_coadd_fit(self, gmix_guess):
"""
run the fixed-center em fitter on the coadd image
"""
coadd_obs = self.coadd_obs
imsky, sky = ngmix.em.prep_image(coadd_obs.image)
emobs = ngmix.Observation(
imsky,
weight=coadd_obs.weight,
jacobian=coadd_obs.jacobian,
psf=coadd_obs.psf,
ignore_zero_weight=self._ignore_zero_weight,
)
em = GMixEMFixCen(
emobs,
miniter=self.miniter,
maxiter=self.maxiter,
tol=self.tol,
vary_sky=self.vary_sky,
)
em.go(gmix_guess, sky)
return em
def _get_band_fit(self, obs):
"""
get the flux-only fit for a band
"""
imsky, sky = ngmix.em.prep_image(obs.image)
emobs = ngmix.Observation(
imsky,
weight=obs.weight,
jacobian=obs.jacobian,
psf=obs.psf,
ignore_zero_weight=self._ignore_zero_weight,
)
em = GMixEMPOnly(
emobs,
miniter=self.flux_miniter,
maxiter=self.flux_maxiter,
tol=self.tol,
vary_sky=self.vary_sky,
)
gm_guess = self._get_band_guess()
em.go(gm_guess, sky)
return em
def _get_psf_obs(self, band, midrow, midcol):
"""
get the image and wieght for the specified box
Parameters
----------
band: int
band to load
ranges: tuple
(minrow, maxrow, mincol, maxcol)
Returns
-------
image, weight
"""
psf = self.psf_list[band]
rrow = round(midrow)
rcol = round(midcol)
image = psf.get_rec(rrow, rcol)
cen = psf.get_center(rrow, rcol)
weight = image*0 + 1.0/0.001**2
jacob = self._get_jacobian(band, midrow, midcol)
jacob.set_cen(row=cen[0], col=cen[1])
return ngmix.Observation(
image,
weight=weight,
jacobian=jacob,
)
def _extract_mbobs(self, ranges, wout):
"""
extract an ngmix.MultiBandObsList for the given region, filling noise
in the regions not assigned to the requested objects
Parameters
----------
ranges: tuple
(minrow, maxrow, mincol, maxcol)
wout: tuple of arrays
(wrows, wcols) indices for areas not assigned to
the objects of interest
Returns
-------
mbobs: ngmix.MultiBandObsList
"""
minrow, maxrow, mincol, maxcol = ranges
midrow = (minrow + maxrow)/2
midcol = (mincol + maxcol)/2
mbobs = ngmix.MultiBandObsList()
for band in range(self.nband):
image, weight, mask = self._get_image_data(band, ranges)
jacob = self._get_jacobian(band, midrow, midcol)
psf_obs = self._get_psf_obs(band, midrow, midcol)
_replace_with_noise(image, weight, wout, self.rng)
if self._rescale:
scale = jacob.scale
image *= 1.0/scale**2
weight *= scale**4
# zero the weight map for bad pixels. Note we are doing this after
# replacing non-member objects pixels with noise, in case the
# weight map ends up all zero
if self._zero_weight_badpix is not None:
_zero_weight_map_for_badpix(
mask, weight, self._zero_weight_badpix,
)
obs = ngmix.Observation(
image,
weight=weight,
jacobian=jacob,
psf=psf_obs,
ignore_zero_weight=self._ignore_zero_weight,
)
obslist = ngmix.ObsList()
obslist.append(obs)
mbobs.append(obslist)
return mbobs
def _get_obs(rng):
"""
obs with noise image included
"""
noise = 0.1
psf_noise = 1.0e-6
scale = 0.263
psf_fwhm = 0.9
gal_fwhm = 0.7
psf = galsim.Gaussian(fwhm=psf_fwhm)
obj0 = galsim.Gaussian(fwhm=gal_fwhm)
obj = galsim.Convolve(psf, obj0)
psf_im = psf.drawImage(scale=scale).array
im = obj.drawImage(scale=scale).array
cen = (np.array(im.shape) - 1.0) / 2.0
psf_cen = (np.array(psf_im.shape) - 1.0) / 2.0
j = ngmix.DiagonalJacobian(row=cen[0], col=cen[1], scale=scale)
pj = ngmix.DiagonalJacobian(row=psf_cen[0], col=psf_cen[1], scale=scale)
wt = im * 0 + 1.0 / noise**2
psf_wt = psf_im * 0 + 1.0 / psf_noise**2
psf_obs = ngmix.Observation(
psf_im,
weight=psf_wt,
jacobian=pj,
)
im += rng.normal(scale=noise, size=im.shape)
psf_im += rng.normal(scale=psf_noise, size=psf_im.shape)
nim = rng.normal(scale=noise, size=im.shape)
obs = ngmix.Observation(
im,
weight=wt,
noise=nim,
jacobian=j,
psf=psf_obs,
)
return obs
def _set_obs(self):
import ngmix
self.obs = ngmix.Observation(
image=self.image,
weight=self.weight_image,
jacobian=self.jacobian,
)
def test_gmix_s2n_smoke():
pars = [0, 0, 0, 0, 5, 1]
gm = ngmix.GMixModel(pars, "gauss")
im = gm.make_image([10, 10])
obs = ngmix.Observation(im)
gm.get_model_s2n(obs)
def trim_obs(*, obs):
"""
trim the images to the default radius, returning a new Observation
Parameters
----------
obs: ngmix.Observation
Observation to trim
Returns
----------
new_obs: ngmix.Observation
Trimmed Observation
"""
j = obs.jacobian
row, col = j.cen
irow, icol = int(row), int(col)
row_start = irow - RADIUS
row_end = irow + RADIUS + 1
col_start = icol - RADIUS
col_end = icol + RADIUS + 1
new_image = obs.image[
row_start:row_end,
col_start:col_end,
]
new_weight = obs.weight[
row_start:row_end,
col_start:col_end,
]
if obs.has_bmask():
new_bmask = obs.bmask[
row_start:row_end,
col_start:col_end,
]
else:
new_bmask = None
new_rowcen = RADIUS + row-irow
new_colcen = RADIUS + col-icol
new_jac = j.copy()
new_jac.set_cen(row=new_rowcen, col=new_colcen)
if obs.has_psf():
new_psf = trim_obs(obs=obs.psf)
else:
new_psf = None
return ngmix.Observation(
image=new_image,
weight=new_weight,
bmask=new_bmask,
jacobian=new_jac,
psf=new_psf,
meta=obs.meta,
)
def make_stamp_obs(obj_data, obs, stamp_dim):
"""
extract a postage stamp and make an Observation
Parameters
----------
obj_data: array
Scalar array representing an object's data from sep
obs: Observation
The observation from which to extract postage stamp data
stamp_dim: int
Dims of the stamp to extract
Returns
-------
Observation
"""
half_box_size = stamp_dim//2
maxrow, maxcol = obs.image.shape
row = obj_data['y'].astype('i4')
col = obj_data['x'].astype('i4')
start_row = row - half_box_size + 1
end_row = row + half_box_size + 1 # plus one for slices
start_col = col - half_box_size + 1
end_col = col + half_box_size + 1
if start_row < 0:
return 1, None
# start_row = 0
if start_col < 0:
return 1, None
# start_col = 0
if end_row > maxrow:
return 1, None
# end_row = maxrow
if end_col > maxcol:
return 1, None
# end_col = maxcol
image = obs.image[start_row:end_row, start_col:end_col].copy()
weight = obs.weight[start_row:end_row, start_col:end_col].copy()
stamp_row = obj_data['y'] - start_row
stamp_col = obj_data['x'] - start_col
jacobian = obs.jacobian.copy()
jacobian.set_cen(row=stamp_row, col=stamp_col)
stamp_obs = ngmix.Observation(
image=image,
weight=weight,
jacobian=jacobian,
)
return 0, stamp_obs
def make_mbobs(*, band_data, rng):
mbobs = ngmix.MultiBandObsList()
for band, bdata in band_data.items():
obslist = ngmix.ObsList()
for epoch_ind, se_obs in enumerate(bdata):
ny, nx = se_obs.image.array.shape
cenx = (nx - 1) / 2
ceny = (ny - 1) / 2
jacobian = get_jac(wcs=se_obs.wcs, cenx=cenx, ceny=ceny)
psf_gsimage = se_obs.get_psf(
cenx,
ceny,
center_psf=False,
)
psf_image = psf_gsimage.array
psf_cen = (np.array(psf_image.shape) - 1) / 2
psf_jac = jacobian.copy()
psf_jac.set_cen(row=psf_cen[0], col=psf_cen[1])
psf_noise_fake = psf_image.max() / 50000
psf_image += rng.normal(scale=psf_noise_fake, size=psf_image.shape)
psf_weight = psf_image * 0 + 1.0 / psf_noise_fake**2
psf_obs = ngmix.Observation(
image=psf_image,
weight=psf_weight,
jacobian=psf_jac,
)
obs = ngmix.Observation(
image=se_obs.image.array,
weight=se_obs.weight.array,
jacobian=jacobian,
psf=psf_obs,
)
obslist.append(obs)
mbobs.append(obslist)
return mbobs
def make_data(
rng,
counts=100.0,
g1=0.0,
g2=0.0,
noise=0.0,
):
pixel_scale = 0.263
dims = [32] * 2
cen = (np.array(dims) - 1) / 2
dvdrow, dvdcol, dudrow, dudcol = pixel_scale, -0.02, 0.01, pixel_scale
jacobian = ngmix.Jacobian(
row=cen[0],
col=cen[1],
dvdrow=dvdrow,
dvdcol=dvdcol,
dudrow=dudrow,
dudcol=dudcol,
)
pars1 = [
-3.25 * pixel_scale,
-3.25 * pixel_scale,
0.05,
0.025,
0.55,
0.4 * counts,
]
pars2 = [
3.0 * pixel_scale,
0.5 * pixel_scale,
-0.1,
-0.05,
0.27,
0.6 * counts,
]
gm1 = ngmix.GMixModel(pars1, "gauss")
gm2 = ngmix.GMixModel(pars2, "gauss")
full_pars = np.hstack([gm1.get_full_pars(), gm2.get_full_pars()])
gm = ngmix.GMix(pars=full_pars)
im0 = gm.make_image(dims, jacobian=jacobian)
im = im0 + rng.normal(size=im0.shape, scale=noise)
obs = ngmix.Observation(image=im, jacobian=jacobian)
return obs, gm
def test_gmix_errors():
with pytest.raises(ValueError):
ngmix.GMix()
with pytest.raises(ValueError):
ngmix.GMixModel([1] * 6, "blah")
with pytest.raises(ValueError):
ngmix.GMix(pars=[1] * 10)
with pytest.raises(ValueError):
ngmix.GMix(ngauss=-1)
with pytest.raises(ValueError):
ngmix.GMixModel([1] * 10, "gauss")
pars = [0, 0, 0, 0, 10, 1]
gm = ngmix.GMixModel(pars, "gauss")
with pytest.raises(ValueError):
gm.get_sheared(0.1)
with pytest.raises(TypeError):
gm.convolve(3)
with pytest.raises(ValueError):
gm.make_image([1])
obs = ngmix.Observation(np.zeros((10, 10)))
with pytest.raises(ValueError):
gm.fill_fdiff(obs, np.zeros((10, 10)), start=100000)
with pytest.raises(TypeError):
gm.make_galsim_object(gsparams=3)
with pytest.raises(ValueError):
gm = ngmix.GMixCoellip([1] * 3)
with pytest.raises(ValueError):
ngmix.gmix.get_model_name(-1)
with pytest.raises(ValueError):
ngmix.gmix.get_model_num('asdfsa')
with pytest.raises(ValueError):
ngmix.gmix.get_model_ngauss('asdfsa')
with pytest.raises(ValueError):
ngmix.gmix.get_model_npars('asdfsa')
with pytest.raises(ValueError):
tgm = gm.copy()
tgm._model_name = 'sdfasd'
tgm._set_fill_func()
def _get_mof_obs(self):
im, psf_im, coords, dims, dx1, dy1, noise, sep_coords = self.sim()
#import images
#images.view(im)
#if 'q'==input('hit a key'):
# stop
bg_rms = self.sim['Image']['Bgrms']
bg_rms_psf = self.sim['Psf']['Bgrms_psf']
psf_ccen = (np.array(psf_im.shape) - 1.0) / 2.0
psf_jacob = ngmix.UnitJacobian(
row=psf_ccen[0],
col=psf_ccen[1],
)
psf_weight = psf_im * 0 + 1.0 / bg_rms_psf**2
psf_obs = ngmix.Observation(
psf_im,
weight=psf_weight,
jacobian=psf_jacob,
)
psf_gmix = self._fit_psf_admom(psf_obs)
psf_obs.set_gmix(psf_gmix)
weight = im * 0 + 1.0 / bg_rms**2
jacobian = ngmix.UnitJacobian(
row=0,
col=0,
)
obs = ngmix.Observation(
im,
weight=weight,
jacobian=jacobian,
psf=psf_obs,
)
obs.noise = noise
return obs, sep_coords, dims
def _one_gal_obs(self, source_id=None, psf_noise=1e-6):
index = source_id
jaclist = self._get_jacobians(source_id)
psf_cutout = self.medsObj.get_cutout(index, 0, type='psf')
image_cutout = self.medsObj.get_cutout(index, 0)
weight_cutout = self.medsObj.get_cutout(index, 0, type='weight')
# to help Bootstrapper distinguish between object and background
image_cutout[~np.isfinite(image_cutout)] = 0.
image_cutout[image_cutout <= 0] = 1E-2
psf_noise = 1e-6
this_psf = psf_cutout + 1e-6 * np.random.randn(psf_cutout.shape[0],
psf_cutout.shape[1])
psf_weight_image = np.zeros_like(this_psf) + 1. / psf_noise**2
sky_sigma = (0.0557 *
300)**2 # exp_time = 300, sky_var = 0.0957 ADU/pix/s
weight_image = np.zeros_like(image_cutout) + 1. / sky_sigma
jj_im = ngmix.jacobian.DiagonalJacobian(scale=0.206,
x=(image_cutout.shape[0]) / 2,
y=(image_cutout.shape[1]) / 2)
jj_psf = ngmix.jacobian.DiagonalJacobian(scale=0.206,
x=psf_cutout.shape[0] / 2,
y=psf_cutout.shape[1] / 2)
psf_obs = ngmix.Observation(psf_cutout,
weight=psf_weight_image,
jacobian=jj_psf)
gal_obs = ngmix.Observation(image_cutout,
weight=weight_image,
jacobian=jj_im,
psf=psf_obs)
return gal_obs
def get_psf_obs(psfim, jacobian):
cen = (np.array(psfim.shape)-1.0)/2.0
j = jacobian.copy()
j.set_cen(row=cen[0], col=cen[1])
psf_obs = ngmix.Observation(
psfim,
weight=psfim*0+1,
jacobian=j
)
gmix = fitpsf(psf_obs)
psf_obs.set_gmix(gmix)
return psf_obs
def test_ml_fitting_galsim_moffat_smoke():
rng = np.random.RandomState(seed=2312)
scale = 0.263
fwhm = 0.9
beta = 2.5
image_size = 33
flux = 1.0
noise = 1.0e-5
moff = galsim.Moffat(fwhm=fwhm, beta=beta, flux=flux)
im = moff.drawImage(
nx=image_size,
ny=image_size,
scale=scale,
).array
im += rng.normal(scale=noise, size=im.shape)
weight = im * 0 + 1.0 / noise**2
cen = (image_size - 1.0) / 2.0
jac = ngmix.DiagonalJacobian(
y=cen,
x=cen,
scale=scale,
)
obs = ngmix.Observation(
image=im,
weight=weight,
jacobian=jac,
)
fitter = ngmix.fitting.GalsimMoffatFitter()
guess = np.zeros(7)
guess[0] = rng.uniform(low=-0.1, high=0.1)
guess[1] = rng.uniform(low=-0.1, high=0.1)
guess[2] = rng.uniform(low=-0.1, high=0.1)
guess[3] = rng.uniform(low=-0.1, high=0.1)
guess[4] = moff.half_light_radius * rng.uniform(low=0.9, high=1.1)
guess[5] = rng.uniform(low=1.5, high=3)
guess[6] = flux * rng.uniform(low=0.9, high=1.1)
res = fitter.go(obs=obs, guess=guess)
assert res['flags'] == 0
def _measure_moments(self, gs_kimage, weight):
import ngmix
if self._deweight:
raise NotImplementedError("no dweight yet for gauss moms")
dk = gs_kimage.scale
dk2 = dk**2
dk4 = dk**4
kwt, cen, dims = self._get_weight_object(gs_kimage)
jacob = ngmix.UnitJacobian(
row=cen[0],
col=cen[1],
)
medwt = numpy.median(weight)
dim = weight.shape[0]
#noise_factor=self._get_noise_factor(dim)
noise_factor = dim
weight_factor = 1.0 / noise_factor**2
kivar = zeros(gs_kimage.array.shape) + medwt * weight_factor
kobs = ngmix.Observation(
gs_kimage.array,
weight=kivar,
jacobian=jacob,
)
res = kwt.get_weighted_moments(kobs)
# put onto a common scale
if res['flags'] == 0:
res['pars'][0:0 + 2] *= dk
res['pars'][2:2 + 3] *= dk2
res['pars_cov'][0:0 + 2, 0:0 + 2] *= dk2
res['pars_cov'][2:2 + 2, 2:2 + 2] *= dk4
return res
def _get_coadd_psf_obs(self):
"""
get the psf observation
"""
psf_obj = self.coadd_exp.getPsf()
psf_image = psf_obj.computeKernelImage(self.coadd_cen).array
psf_cen = (np.array(psf_image.shape)-1.0)/2.0
psf_jac = self._get_jac(cenx=psf_cen[1], ceny=psf_cen[0])
psf_err = psf_image.max()*0.0001
psf_weight = psf_image*0 + 1.0/psf_err**2
return ngmix.Observation(
image=psf_image,
weight=psf_weight,
jacobian=psf_jac,
)
