def get_psf_kwargs_update(self,
psf_type,
image,
exp_time,
HDUFile,
pixelScale,
psf_size=None,
psf_size_large=91,
filter_object=None,
kwargs_cut={}):
"""
does the same as get_psf_kwargs but can also restrict itself to specially chosen objects
:param image_name:
:param psf_type:
:param psf_size:
:param filter_object:
:return:
"""
kernel_large, mean_list, restrict_psf, star_list = self.get_psf(
HDUFile, image, exp_time, psf_type, filter_object, kwargs_cut)
if psf_type == 'gaussian':
sigma = mean_list[1] * pixelScale
psf_kwargs = {'psf_type': psf_type, 'sigma': sigma}
elif psf_type == 'moffat':
alpha = mean_list[1]
beta = mean_list[2]
alpha *= pixelScale
psf_kwargs = {'psf_type': psf_type, 'alpha': alpha, 'beta': beta}
elif psf_type == 'pixel':
kernel = util.cut_edges(kernel_large, psf_size)
kernel = util.kernel_norm(kernel)
kernel_large = util.cut_edges(kernel_large, psf_size_large)
kernel_large = util.kernel_norm(kernel_large)
kernel_list = []
for i in range(len(star_list)):
if i == 0:
kernel_list.append(kernel_large)
else:
star = star_list[i]
kernel_star = util.cut_edges(star, psf_size_large)
kernel_star = util.kernel_norm(kernel_star)
kernel_list.append(kernel_star - kernel_large)
psf_kwargs = {
'psf_type': psf_type,
'kernel': kernel,
'kernel_large': kernel_large,
'kernel_list': kernel_list
}
else:
raise ValueError('psf type %s not in list' % psf_type)
return psf_kwargs, restrict_psf, star_list
def get_psf_errors(self, kernel, sigma_bkg, star_list):
"""
returns a error map of sigma prop Intensity for a stacked psf estimation
:param psf_kwargs:
:param star_list:
:return:
"""
psf_size = len(kernel)
kernel_mean = util.image2array(kernel)
weights = np.zeros(len(star_list))
cov_i = np.zeros((psf_size**2, psf_size**2))
num_stars = len(star_list)
for i in range(0, num_stars):
star_list_i = star_list[i].copy()
star = util.cut_edges(star_list_i, psf_size)
weights[i] = np.sum(star)
rel_array = np.array(
[util.image2array(star) / weights[i] - kernel_mean])
a = (rel_array.T).dot(rel_array)
cov_i += a
factor = 1. / (num_stars)
#weights_sum = sum(weights)
sigma2_stack = factor * util.array2image(np.diag(cov_i))
psf_stack = copy.deepcopy(kernel)
sigma2_stack_new = sigma2_stack # - (data_kwargs['sigma_background']**2/weights_sum)
sigma2_stack_new[np.where(sigma2_stack_new < 0)] = 0
psf_stack[np.where(psf_stack < sigma_bkg)] = sigma_bkg
error_map = sigma2_stack_new / (psf_stack)**2
#error_map[np.where(error_map < psf_stack**2/data_kwargs['reduced_noise'])] = 0
# n = len(error_map)
#error_map[(n-1)/2-1:(n-1)/2+2,(n-1)/2-1:(n-1)/2+2] += 0
#error_map = filters.gaussian_filter(error_map, sigma=0.5)
return error_map
def fit_sample(self,
star_list,
mean,
sigma,
poisson,
n_walk=100,
n_iter=100,
threadCount=1,
psf_type='gaussian'):
"""
routine to fit a sample of several stars and to show the variation
:param mean:
:param sigma:
:param poisson:
:param walkerRatio:
:param n_run:
:param n_burn:
:param threadCount:
:return:
"""
n = len(star_list) # number of different objects
if psf_type == 'gaussian' or psf_type == 'pixel':
numParam = 4
elif psf_type == 'moffat':
numParam = 5
else:
raise ValueError('type %s is not a valid input' % (type))
mean_list = np.zeros((n, numParam))
for i in range(n):
image = star_list[i]
image = util.cut_edges(image, 33)
if psf_type == 'gaussian' or psf_type == 'pixel':
mean_list[i] = self.gaussian_fit(image,
mean,
sigma,
poisson,
n_walker=n_walk,
n_iter=n_iter,
threadCount=threadCount)
elif psf_type == 'moffat':
mean_list[i] = self.moffat_fit(image,
mean,
sigma,
poisson,
n_walker=n_walk,
n_iter=n_iter,
threadCount=threadCount)
return mean_list