def test_ne(): """ Check that inequality works as expected.""" gsp = galsim.GSParams(maxk_threshold=1.1e-3, folding_threshold=5.1e-3) gal1 = galsim.Gaussian(fwhm=1) gal2 = galsim.Gaussian(fwhm=2) # Sum. Params are objs to add and potentially gsparams. gals = [ galsim.Sum(gal1), galsim.Sum(gal1, gal2), galsim.Sum(gal2, gal1), # Not! commutative. galsim.Sum(galsim.Sum(gal1, gal2), gal2), galsim.Sum(gal1, galsim.Sum(gal2, gal2)), # Not! associative. galsim.Sum(gal1, gsparams=gsp) ] all_obj_diff(gals) # Convolution. Params are objs to convolve and potentially gsparams. # The following should test unequal gals = [ galsim.Convolution(gal1), galsim.Convolution(gal1, gal2), galsim.Convolution(gal2, gal1), # Not! commutative. galsim.Convolution(gal1, gal2, real_space=True), galsim.Convolution(galsim.Convolution(gal1, gal2), gal2), galsim.Convolution(gal1, galsim.Convolution(gal2, gal2)), # Not! associative. galsim.Convolution(gal1, gsparams=gsp) ] all_obj_diff(gals) # Deconvolution. Only params here are obj to deconvolve and gsparams. gals = [ galsim.Deconvolution(gal1), galsim.Deconvolution(gal2), galsim.Deconvolution(gal1, gsparams=gsp) ] all_obj_diff(gals) # AutoConvolution. Only params here are obj to deconvolve and gsparams. gals = [ galsim.AutoConvolution(gal1), galsim.AutoConvolution(gal2), galsim.AutoConvolution(gal1, gsparams=gsp) ] all_obj_diff(gals) # AutoCorrelation. Only params here are obj to deconvolve and gsparams. gals = [ galsim.AutoCorrelation(gal1), galsim.AutoCorrelation(gal2), galsim.AutoCorrelation(gal1, gsparams=gsp) ] all_obj_diff(gals)
def __getitem__(self, idx): flux_avg = self._uniform(self.min_flux, self.max_flux) hlr = self._uniform(self.min_hlr, self.max_hlr) # arcseconds flux = (hlr / self.pixel_scale) ** 2 * np.pi * flux_avg # approx # sample ellipticity ell = self._uniform(0, self.max_e) theta = self._uniform(0, 2 * np.pi) g1 = ell * np.cos(theta) g2 = ell * np.sin(theta) # pylint: disable=no-value-for-parameter galaxy = galsim.Gaussian(half_light_radius=hlr).shear(g1=g1, g2=g2).withFlux(flux) gal_conv = galsim.Convolution(galaxy, self.psf) image = gal_conv.drawImage( nx=self.slen, ny=self.slen, method="auto", scale=self.pixel_scale ) # convert image to pytorch and reshape image = torch.from_numpy(image.array).reshape(1, self.slen, self.slen) # add noise and background. image += self.background noise = torch.sqrt(image) * torch.randn(*image.shape) image += noise return {"images": image, "background": self.background}
def dilatePSF(epsf_profile, shear): """ Separate epsf and pixel response, dilate by 1+2g, reconvolve by pixel response epsf_profile must be a Convolution object, not interpolated_image """ obj_list = epsf_profile.obj_list non_pixel = [obj for obj in obj_list if not isinstance(obj, galsim.Pixel)] pixel = [obj for obj in obj_list if isinstance(obj, galsim.Pixel)][0] # assume one pixel object if len(non_pixel) > 1: non_pixel = galsim.Convolution(non_pixel) else: non_pixel = non_pixel[0] dilation = 1.0 + 2.0 * shear.g dil_psf = non_pixel.dilate(dilation) reconv_psf = galsim.Convolution(dil_psf, pixel) return reconv_psf
def make_fft_psf(self, psf, logger): """Swap out any PhaseScreenPSF component with a roughly equivalent analytic approximation. """ if isinstance(psf, galsim.Transformation): return galsim.Transformation(self.make_fft_psf(psf.original, logger), psf.jac, psf.offset, psf.flux_ratio, psf.gsparams) elif isinstance(psf, galsim.Convolution): obj_list = [self.make_fft_psf(p, logger) for p in psf.obj_list] return galsim.Convolution(obj_list, gsparams=psf.gsparams) elif isinstance(psf, galsim.PhaseScreenPSF): # If psf is a PhaseScreenPSF, then make a simpler one the just convolves # a Kolmogorov profile with an OpticalPSF. r0_500 = psf.screen_list.r0_500_effective atm_psf = galsim.Kolmogorov(lam=psf.lam, r0_500=r0_500, gsparams=psf.gsparams) opt_screens = [s for s in psf.screen_list if isinstance(s, galsim.OpticalScreen)] logger.info('opt_screens = %r',opt_screens) if len(opt_screens) >= 1: # Should never be more than 1, but if there weirdly is, just use the first. opt_screen = opt_screens[0] optical_psf = galsim.OpticalPSF( lam=psf.lam, diam=opt_screen.diam, aberrations=opt_screen.aberrations, annular_zernike=opt_screen.annular_zernike, obscuration=opt_screen.obscuration, gsparams=psf.gsparams) return galsim.Convolve([atm_psf, optical_psf], gsparams=psf.gsparams) else: return atm_psf else: return psf
def test_measurements(): slen = 40 pixel_scale = 0.2 psf = galsim.Gaussian(sigma=0.2) gal = galsim.Gaussian(sigma=1.0) gal_conv = galsim.Convolution(gal, psf) psf_image = psf.drawImage(nx=slen, ny=slen, scale=pixel_scale).array.reshape(1, slen, slen) image = gal_conv.drawImage(nx=slen, ny=slen, scale=pixel_scale).array.reshape(1, 1, slen, slen) image, psf_image = torch.from_numpy(image), torch.from_numpy(psf_image) reporting.get_single_galaxy_measurements(image, psf_image, pixel_scale)
def test_ne(): import time t1 = time.time() gsp = galsim.GSParams(maxk_threshold=1.1e-3, folding_threshold=5.1e-3) gal1 = galsim.Gaussian(fwhm=1) gal2 = galsim.Gaussian(fwhm=2) # Sum. Params are objs to add and potentially gsparams. gals = [galsim.Sum(gal1), galsim.Sum(gal1, gal2), galsim.Sum(gal2, gal1), # Not! commutative. galsim.Sum(galsim.Sum(gal1, gal2), gal2), galsim.Sum(gal1, galsim.Sum(gal2, gal2)), # Not! associative. galsim.Sum(gal1, gsparams=gsp)] all_obj_diff(gals) # Convolution. Params are objs to convolve and potentially gsparams. # The following should test unequal gals = [galsim.Convolution(gal1), galsim.Convolution(gal1, gal2), galsim.Convolution(gal2, gal1), # Not! commutative. galsim.Convolution(gal1, gal2, real_space=True), galsim.Convolution(galsim.Convolution(gal1, gal2), gal2), galsim.Convolution(gal1, galsim.Convolution(gal2, gal2)), # Not! associative. galsim.Convolution(gal1, gsparams=gsp)] all_obj_diff(gals) # Deconvolution. Only params here are obj to deconvolve and gsparams. gals = [galsim.Deconvolution(gal1), galsim.Deconvolution(gal2), galsim.Deconvolution(gal1, gsparams=gsp)] all_obj_diff(gals) # AutoConvolution. Only params here are obj to deconvolve and gsparams. gals = [galsim.AutoConvolution(gal1), galsim.AutoConvolution(gal2), galsim.AutoConvolution(gal1, gsparams=gsp)] all_obj_diff(gals) # AutoCorrelation. Only params here are obj to deconvolve and gsparams. gals = [galsim.AutoCorrelation(gal1), galsim.AutoCorrelation(gal2), galsim.AutoCorrelation(gal1, gsparams=gsp)] all_obj_diff(gals) t2 = time.time() print 'time for %s = %.2f'%(funcname(),t2-t1)
def simple_model(self, e, half_light_radius, theta_int, flux, g1=0., g2=0.): '''Simple image model, only involves key parameters to describe an image This function is used to find the major axis direction of image only data ''' disk = galsim.Sersic(n=1, half_light_radius=half_light_radius, flux=flux, trunc=4*half_light_radius) disk = disk.shear(g1=e/2., g2=0.0) disk = disk.rotate(theta_int*galsim.radians) disk = disk.shear(g1=g1, g2=g2) galObj = galsim.Convolution([disk, self.psf]) _image = galsim.Image(self.image.ngrid, self.image.ngrid, scale=self.image.pixScale) newImage = galObj.drawImage(image=_image) return newImage.array
def forward_model(self, pars): disk = galsim.Sersic(n=1, half_light_radius=pars['r_hl_image'], flux=pars['flux'], trunc=4*pars['r_hl_image']) e = cal_e_int(sini=pars['sini'], q_z=pars['aspect']) g1_int = e/2. disk = disk.shear(g1=g1_int, g2=0.0) disk = disk.rotate(pars['theta_int']*galsim.radians) disk = disk.shear(g1=pars['g1'], g2=pars['g2']) galObj = galsim.Convolution([disk, self.psf]) image0 = galsim.Image(pars['ngrid'], pars['ngrid'], scale=pars['subGridPixScale']) image = galObj.drawImage(image=image0) return image.array
def render_galaxy( self, galaxy_params: Tensor, psf: galsim.GSObject, slen: int, offset: Optional[Tensor] = None, ) -> Tensor: assert offset is None or offset.shape == (2, ) if isinstance(galaxy_params, Tensor): galaxy_params = galaxy_params.cpu().detach() total_flux, disk_frac, beta_radians, disk_q, a_d, bulge_q, a_b = galaxy_params bulge_frac = 1 - disk_frac disk_flux = total_flux * disk_frac bulge_flux = total_flux * bulge_frac components = [] if disk_flux > 0: b_d = a_d * disk_q disk_hlr_arcsecs = np.sqrt(a_d * b_d) disk = galsim.Exponential( flux=disk_flux, half_light_radius=disk_hlr_arcsecs).shear( q=disk_q, beta=beta_radians * galsim.radians, ) components.append(disk) if bulge_flux > 0: b_b = bulge_q * a_b bulge_hlr_arcsecs = np.sqrt(a_b * b_b) bulge = galsim.DeVaucouleurs( flux=bulge_flux, half_light_radius=bulge_hlr_arcsecs).shear( q=bulge_q, beta=beta_radians * galsim.radians) components.append(bulge) galaxy = galsim.Add(components) gal_conv = galsim.Convolution(galaxy, psf) offset = offset if offset is None else offset.numpy() image = gal_conv.drawImage(nx=slen, ny=slen, method="auto", scale=self.pixel_scale, offset=offset) return torch.from_numpy(image.array).reshape(1, slen, slen)
def applyPSF(self, xPupil=None, yPupil=None, obj=None, **kwargs): """ Apply the PSF to a GalSim GSObject This method accepts the x and y pupil coordinates in arc seconds as well as a GalSim GSObject. The method calculates the PSF parameters based on xPupil and yPupil, constructs a Galsim GSObject corresponding to the PSF function, and convolves the PSF with the GSObject, returning the result of the convolution. In the case of point sources, this object returns the raw PSF, rather than attempting a convolution (since there is nothing to convolve with). @param [in] xPupil the x pupil coordinate in arc seconds @param [in] yPupil the y pupil coordinate in arc seconds @param [in] obj is a GalSim GSObject (an astronomical object) with which to convolve the PSF (optional) """ #use the user-defined _getPSF method to calculate the PSF at these specific #coordinates and (optionally) wavelength psf = self._getPSF(xPupil=xPupil, yPupil=yPupil, **kwargs) if obj is None: #if there is no object, use a DeltaFunction as a point source obj = galsim.DeltaFunction() #convolve obj with the psf if isinstance(psf, galsim.Convolution): # If the psf is itself a Convolution object, convolve obj # with the individual components to ensure that the # obj_list of the returned obj lists those components # separately. return galsim.Convolution([obj] + psf.obj_list) else: return galsim.Convolve(obj, psf)
def test_convolve_noise(): """Test that noise propagation works properly for compount objects. """ obj1 = galsim.Gaussian(sigma=1.7) obj2 = galsim.Gaussian(sigma=2.3) obj1.noise = galsim.UncorrelatedNoise(variance=0.3, scale=0.2) obj2.noise = galsim.UncorrelatedNoise(variance=0.5, scale=0.2) obj3 = galsim.Gaussian(sigma=2.9) # Convolve convolves the noise from a single component conv2 = galsim.Convolution([obj1, obj3]) noise = galsim.Convolve([obj1.noise._profile, obj3, obj3]) # xValue is too slow here. Use drawImage to get variance. (Just as CorrelatedNoise does.) variance = noise.drawImage(nx=1, ny=1, scale=1., method='sb')(1, 1) np.testing.assert_almost_equal( conv2.noise.getVariance(), variance, err_msg= "Convolution of two objects did not correctly propagate noise varinace" ) conv2 = galsim.Convolution([obj2, obj3]) noise = galsim.Convolve([obj2.noise._profile, obj3, obj3]) variance = noise.drawImage(nx=1, ny=1, scale=1., method='sb')(1, 1) np.testing.assert_almost_equal( conv2.noise.getVariance(), variance, err_msg= "Convolution of two objects did not correctly propagate noise varinace" ) # Convolution of multiple objects with noise attributes raises a warning and fails # to propagate noise properly. (It takes the input noise from the first one.) conv2 = galsim.Convolution(obj1, obj2) conv3 = galsim.Convolution(obj1, obj2, obj3) with assert_warns(galsim.GalSimWarning): assert conv2.noise == obj1.noise.convolvedWith(obj2) with assert_warns(galsim.GalSimWarning): assert conv3.noise == obj1.noise.convolvedWith( galsim.Convolve(obj2, obj3)) # Convolution with only one object uses that object's noise conv1 = galsim.Convolution(obj1) assert conv1.noise == obj1.noise # Other types don't propagate noise and give a warning about it. deconv = galsim.Deconvolution(obj2) autoconv = galsim.AutoConvolution(obj2) autocorr = galsim.AutoCorrelation(obj2) four = galsim.FourierSqrt(obj2) with assert_warns(galsim.GalSimWarning): assert deconv.noise is None with assert_warns(galsim.GalSimWarning): assert autoconv.noise is None with assert_warns(galsim.GalSimWarning): assert autocorr.noise is None with assert_warns(galsim.GalSimWarning): assert four.noise is None obj2.noise = None # Remove obj2 noise for the rest. conv2 = galsim.Convolution(obj1, obj2) noise = galsim.Convolve([obj1.noise._profile, obj2, obj2]) variance = noise.drawImage(nx=1, ny=1, scale=1., method='sb')(1, 1) np.testing.assert_almost_equal( conv2.noise.getVariance(), variance, err_msg= "Convolution of two objects did not correctly propagate noise varinace" ) conv3 = galsim.Convolution(obj1, obj2, obj3) noise = galsim.Convolve([obj1.noise._profile, obj2, obj2, obj3, obj3]) variance = noise.drawImage(nx=1, ny=1, scale=1., method='sb')(1, 1) np.testing.assert_almost_equal( conv3.noise.getVariance(), variance, err_msg= "Convolution of three objects did not correctly propagate noise varinace" ) deconv = galsim.Deconvolution(obj2) autoconv = galsim.AutoConvolution(obj2) autocorr = galsim.AutoCorrelation(obj2) four = galsim.FourierSqrt(obj2) assert deconv.noise is None assert autoconv.noise is None assert autocorr.noise is None assert four.noise is None
def test_convolve(): """Test the convolution of a Moffat and a Box profile against a known result. """ dx = 0.2 # Using an exact Maple calculation for the comparison. Only accurate to 4 decimal places. savedImg = galsim.fits.read(os.path.join(imgdir, "moffat_pixel.fits")) myImg = galsim.ImageF(savedImg.bounds, scale=dx) myImg.setCenter(0, 0) # Code was formerly: # psf = galsim.Moffat(beta=1.5, truncationFWHM=4, flux=1, half_light_radius=1) # # ...but this is no longer quite so simple since we changed the handling of trunc to be in # physical units. However, the same profile can be constructed using # fwhm=1.0927449310213702, # as calculated by interval bisection in devutils/external/calculate_moffat_radii.py fwhm_backwards_compatible = 1.0927449310213702 psf = galsim.Moffat(beta=1.5, fwhm=fwhm_backwards_compatible, trunc=4 * fwhm_backwards_compatible, flux=1) pixel = galsim.Pixel(scale=dx, flux=1.) # Note: Since both of these have hard edges, GalSim wants to do this with real_space=True. # Here we are intentionally tesing the Fourier convolution, so we want to suppress the # warning that GalSim emits. with assert_warns(galsim.GalSimWarning): # We'll do the real space convolution below conv = galsim.Convolve([psf, pixel], real_space=False) conv.drawImage(myImg, scale=dx, method="sb", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 4, err_msg="Moffat convolved with Pixel disagrees with expected result" ) assert psf.gsparams is galsim.GSParams.default assert pixel.gsparams is galsim.GSParams.default assert conv.gsparams is galsim.GSParams.default # Other ways to do the convolution: conv = galsim.Convolve(psf, pixel, real_space=False) conv.drawImage(myImg, scale=dx, method="sb", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 4, err_msg= "Using GSObject Convolve(psf,pixel) disagrees with expected result" ) assert conv.gsparams is galsim.GSParams.default # Check with default_params conv = galsim.Convolve([psf, pixel], real_space=False, gsparams=default_params) conv.drawImage(myImg, scale=dx, method="sb", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 4, err_msg= "Using GSObject Convolve([psf,pixel]) with default_params disagrees with" "expected result") # In this case, it's not the same object, but it should be == assert conv.gsparams is not galsim.GSParams.default assert conv.gsparams == galsim.GSParams.default assert conv.gsparams is default_params # Also the components shouldn't have changed. assert conv.obj_list[0] is psf assert conv.obj_list[1] is pixel conv = galsim.Convolve([psf, pixel], real_space=False, gsparams=galsim.GSParams()) conv.drawImage(myImg, scale=dx, method="sb", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 4, err_msg= "Using GSObject Convolve([psf,pixel]) with GSParams() disagrees with" "expected result") assert conv.gsparams is not galsim.GSParams.default assert conv.gsparams == galsim.GSParams.default cen = galsim.PositionD(0, 0) np.testing.assert_equal(conv.centroid, cen) np.testing.assert_almost_equal(conv.flux, psf.flux * pixel.flux) # Not almost_equal. Convolutions don't give a very good estimate. # They are almost always too high, which is actually ok for how we use max_sb for phot shooting. np.testing.assert_array_less(conv.xValue(cen), conv.max_sb) check_basic(conv, "Moffat * Pixel") # Test photon shooting. with assert_warns(galsim.GalSimWarning): do_shoot(conv, myImg, "Moffat * Pixel") # Convolution of just one argument should be equivalent to that argument. single = galsim.Convolve(psf) gsobject_compare(single, psf) check_basic(single, "`convolution' of single Moffat") do_pickle(single) do_shoot(single, myImg, "single Convolution") single = galsim.Convolve([psf]) gsobject_compare(single, psf) check_basic(single, "`convolution' of single Moffat") do_pickle(single) single = galsim.Convolution(psf) gsobject_compare(single, psf) check_basic(single, "`convolution' of single Moffat") do_pickle(single) single = galsim.Convolution([psf]) gsobject_compare(single, psf) check_basic(single, "`convolution' of single Moffat") do_pickle(single) # Should raise an exception for invalid arguments assert_raises(TypeError, galsim.Convolve) assert_raises(TypeError, galsim.Convolve, myImg) assert_raises(TypeError, galsim.Convolve, [myImg]) assert_raises(TypeError, galsim.Convolve, [psf, myImg]) assert_raises(TypeError, galsim.Convolve, [psf, psf, myImg]) assert_raises(TypeError, galsim.Convolve, [psf, psf], realspace=False) assert_raises(TypeError, galsim.Convolution) assert_raises(TypeError, galsim.Convolution, myImg) assert_raises(TypeError, galsim.Convolution, [myImg]) assert_raises(TypeError, galsim.Convolution, [psf, myImg]) assert_raises(TypeError, galsim.Convolution, [psf, psf, myImg]) assert_raises(TypeError, galsim.Convolution, [psf, psf], realspace=False) with assert_warns(galsim.GalSimWarning): triple = galsim.Convolve(psf, psf, pixel) assert_raises(galsim.GalSimError, triple.xValue, galsim.PositionD(0, 0)) assert_raises(galsim.GalSimError, triple.drawReal, myImg) deconv = galsim.Convolve(psf, galsim.Deconvolve(pixel)) assert_raises(galsim.GalSimError, deconv.xValue, galsim.PositionD(0, 0)) assert_raises(galsim.GalSimError, deconv.drawReal, myImg) assert_raises(galsim.GalSimError, deconv.drawPhot, myImg, n_photons=10) assert_raises(galsim.GalSimError, deconv.makePhot, n_photons=10)