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