add sls psf model (1ca08d23) · Commits · csst-sims / csst_msc_sim

ObservationSim/Config/Config.py

+1 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@ def config_dir(config, work_dir=None, data_dir=None):
		# PSF data directory
		if config["psf_setting"]["psf_model"] == "Interp":
		path_dict["psf_dir"] = os.path.join(path_dict["data_dir"], config["psf_setting"]["psf_dir"])
		path_dict["psf_sls_dir"] = os.path.join(path_dict["data_dir"], config["psf_setting"]["psf_sls_dir"])

		return path_dict

ObservationSim/Instrument/Chip/ChipUtils.py

+16 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,22 @@ def log_info(msg, logger=None):
		else:
		print(msg, flush=True)

		def getChipSLSGratingID(chipID):
		gratingID = ['','']
		if chipID == 1: gratingID = ['GI2', 'GI1']
		if chipID == 2: gratingID = ['GV4', 'GV3']
		if chipID == 3: gratingID = ['GU2', 'GU1']
		if chipID == 4: gratingID = ['GU4', 'GU3']
		if chipID == 5: gratingID = ['GV2', 'GV1']
		if chipID == 10: gratingID = ['GI4', 'GI3']
		if chipID == 21: gratingID = ['GI6', 'GI5']
		if chipID == 26: gratingID = ['GV8', 'GV7']
		if chipID == 27: gratingID = ['GU6', 'GU5']
		if chipID == 28: gratingID = ['GU8', 'GU7']
		if chipID == 29: gratingID = ['GV6', 'GV5']
		if chipID == 30: gratingID = ['GI8', 'GI7']
		return gratingID

		def getChipSLSConf(chipID):
		confFile = ''
		if chipID == 1: confFile = ['CSST_GI2.conf', 'CSST_GI1.conf']

ObservationSim/MockObject/Galaxy.py

+50 −17

Original line number	Diff line number	Diff line
		@@ -248,10 +248,27 @@ class Galaxy(MockObject):

		xOrderSigPlus = {'A':1.3909419820029296,'B':1.4760376591236062,'C':4.035447379743442,'D':5.5684364343742825,'E':16.260021029735388}
		grating_split_pos_chip = 0 + grating_split_pos

		branges = np.zeros([len(bandpass_list), 2])

		# print(hasattr(psf_model, 'bandranges'))

		if hasattr(psf_model, 'bandranges'):
		if psf_model.bandranges is None:
		return 2, None
		if len(psf_model.bandranges) != len(bandpass_list):
		return 2, None
		branges = psf_model.bandranges
		else:
		for i in range(len(bandpass_list)):
		bandpass = bandpass_list[i]
		branges[i, 0] = bandpass_list[i].blue_limit * 10
		branges[i, 1] = bandpass_list[i].red_limit * 10

		psf, pos_shear = psf_model.get_PSF(chip=chip, pos_img=pos_img, bandpass=bandpass, folding_threshold=folding_threshold)
		for i in range(len(bandpass_list)):
		# bandpass = bandpass_list[i]
		brange = branges[i]

		# psf, pos_shear = psf_model.get_PSF(chip=chip, pos_img=pos_img, bandpass=bandpass, folding_threshold=folding_threshold)
		disk = galsim.Sersic(n=self.disk_sersic_idx, half_light_radius=self.hlr_disk, flux=1.0, gsparams=gsp)
		disk_shape = galsim.Shear(g1=self.e1_disk, g2=self.e2_disk)
		disk = disk.shear(disk_shape)
		@@ -272,14 +289,14 @@ class Galaxy(MockObject):
		g2 += fd_shear.g2
		gal_shear = galsim.Shear(g1=g1, g2=g2)
		gal = gal.shear(gal_shear)
		gal = galsim.Convolve(psf, gal)
		# gal = galsim.Convolve(psf, gal)

		if not big_galaxy: # Not apply PSF for very big galaxy
		gal = galsim.Convolve(psf, gal)
		# if fd_shear is not None:
		# gal = gal.shear(fd_shear)
		# if not big_galaxy: # Not apply PSF for very big galaxy
		# gal = galsim.Convolve(psf, gal)
		# # if fd_shear is not None:
		# # gal = gal.shear(fd_shear)

		starImg = gal.drawImage(wcs=chip_wcs_local, offset=offset)
		starImg = gal.drawImage(wcs=chip_wcs_local, offset=offset,method = 'real_space')

		origin_star = [y_nominal - (starImg.center.y - starImg.ymin),
		x_nominal - (starImg.center.x - starImg.xmin)]
		@@ -301,12 +318,16 @@ class Galaxy(MockObject):
		sdp_p1 = SpecDisperser(orig_img=star_p1, xcenter=xcenter_p1,
		ycenter=ycenter_p1, origin=origin_p1,
		tar_spec=normalSED,
		band_start=bandpass.blue_limit * 10, band_end=bandpass.red_limit * 10,
		band_start=brange[0], band_end=brange[1],
		conf=chip.sls_conf[0],
		isAlongY=0,
		flat_cube=flat_cube)

		self.addSLStoChipImage(sdp=sdp_p1, chip=chip, xOrderSigPlus = xOrderSigPlus, local_wcs=chip_wcs_local)
		# self.addSLStoChipImage(sdp=sdp_p1, chip=chip, xOrderSigPlus = xOrderSigPlus, local_wcs=chip_wcs_local)
		pos_shear = self.addSLStoChipImageWithPSF(sdp=sdp_p1, chip=chip, pos_img_local=[xcenter_p1, ycenter_p1],
		psf_model=psf_model, bandNo=i + 1,
		grating_split_pos=grating_split_pos,
		local_wcs=chip_wcs_local)

		subImg_p2 = starImg.array[:, subSlitPos+1:starImg.array.shape[1]]
		star_p2 = galsim.Image(subImg_p2)
		@@ -318,12 +339,16 @@ class Galaxy(MockObject):
		sdp_p2 = SpecDisperser(orig_img=star_p2, xcenter=xcenter_p2,
		ycenter=ycenter_p2, origin=origin_p2,
		tar_spec=normalSED,
		band_start=bandpass.blue_limit * 10, band_end=bandpass.red_limit * 10,
		band_start=brange[0], band_end=brange[1],
		conf=chip.sls_conf[1],
		isAlongY=0,
		flat_cube=flat_cube)

		self.addSLStoChipImage(sdp=sdp_p2, chip=chip, xOrderSigPlus = xOrderSigPlus, local_wcs=chip_wcs_local)
		# self.addSLStoChipImage(sdp=sdp_p2, chip=chip, xOrderSigPlus = xOrderSigPlus, local_wcs=chip_wcs_local)
		pos_shear = self.addSLStoChipImageWithPSF(sdp=sdp_p2, chip=chip, pos_img_local=[xcenter_p2, ycenter_p2],
		psf_model=psf_model, bandNo=i + 1,
		grating_split_pos=grating_split_pos,
		local_wcs=chip_wcs_local)

		del sdp_p1
		del sdp_p2
		@@ -331,25 +356,33 @@ class Galaxy(MockObject):
		sdp = SpecDisperser(orig_img=starImg, xcenter=x_nominal - 0,
		ycenter=y_nominal - 0, origin=origin_star,
		tar_spec=normalSED,
		band_start=bandpass.blue_limit * 10, band_end=bandpass.red_limit * 10,
		band_start=brange[0], band_end=brange[1],
		conf=chip.sls_conf[1],
		isAlongY=0,
		flat_cube=flat_cube)
		self.addSLStoChipImage(sdp=sdp, chip=chip, xOrderSigPlus = xOrderSigPlus, local_wcs=chip_wcs_local)
		# self.addSLStoChipImage(sdp=sdp, chip=chip, xOrderSigPlus = xOrderSigPlus, local_wcs=chip_wcs_local)
		pos_shear = self.addSLStoChipImageWithPSF(sdp=sdp, chip=chip, pos_img_local=[x_nominal, y_nominal],
		psf_model=psf_model, bandNo=i + 1,
		grating_split_pos=grating_split_pos,
		local_wcs=chip_wcs_local)
		del sdp
		elif grating_split_pos_chip>=gal_end[1]:
		sdp = SpecDisperser(orig_img=starImg, xcenter=x_nominal - 0,
		ycenter=y_nominal - 0, origin=origin_star,
		tar_spec=normalSED,
		band_start=bandpass.blue_limit * 10, band_end=bandpass.red_limit * 10,
		band_start=brange[0], band_end=brange[1],
		conf=chip.sls_conf[0],
		isAlongY=0,
		flat_cube=flat_cube)
		self.addSLStoChipImage(sdp=sdp, chip=chip, xOrderSigPlus = xOrderSigPlus, local_wcs=chip_wcs_local)
		# self.addSLStoChipImage(sdp=sdp, chip=chip, xOrderSigPlus = xOrderSigPlus, local_wcs=chip_wcs_local)
		pos_shear = self.addSLStoChipImageWithPSF(sdp=sdp, chip=chip, pos_img_local=[x_nominal, y_nominal],
		psf_model=psf_model, bandNo=i + 1,
		grating_split_pos=grating_split_pos,
		local_wcs=chip_wcs_local)
		del sdp

		# print(self.y_nominal, starImg.center.y, starImg.ymin)
		del psf
		# del psf
		return 1, pos_shear

		def getGSObj(self, psf, g1=0, g2=0, flux=None, filt=None, tel=None, exptime=150.):

ObservationSim/MockObject/MockObject.py

+105 −17

Original line number	Diff line number	Diff line
		@@ -4,7 +4,7 @@ import astropy.constants as cons
		from astropy import wcs
		from astropy.table import Table

		from ObservationSim.MockObject._util import magToFlux, VC_A, convolveGaussXorders
		from ObservationSim.MockObject._util import magToFlux, VC_A, convolveGaussXorders, convolveImg
		from ObservationSim.MockObject._util import integrate_sed_bandpass, getNormFactorForSpecWithABMAG, getObservedSED, \
		getABMAG
		from ObservationSim.MockObject.SpecDisperser import SpecDisperser
		@@ -222,9 +222,69 @@ class MockObject(object):
		del stamp
		del spec_orders

		def addSLStoChipImageWithPSF(self, sdp=None, chip=None, pos_img_local = [1,1], psf_model=None, bandNo = 1, grating_split_pos=3685, local_wcs=None, pos_img=None):
		spec_orders = sdp.compute_spec_orders()
		for k, v in spec_orders.items():
		img_s = v[0]
		# print(bandNo,k)
		try:
		psf, pos_shear = psf_model.get_PSF(chip, pos_img_local = pos_img_local, bandNo = bandNo, galsimGSObject=True, g_order = k, grating_split_pos=grating_split_pos)
		except:
		psf, pos_shear = psf_model.get_PSF(chip=chip, pos_img=pos_img)

		psf_img = psf.drawImage(nx=100, ny=100, wcs = local_wcs)

		psf_img_m = psf_img.array

		#########################################################
		# DEBUG
		#########################################################
		# ids_p = psf_img_m < 0
		# psf_img_m[ids_p] = 0

		# from astropy.io import fits
		# fits.writeto(str(bandNo) + '_' + str(k) + '_psf.fits', psf_img_m)

		# print("DEBUG: orig_off is", orig_off)
		nan_ids = np.isnan(img_s)
		if img_s[nan_ids].shape[0] > 0:
		img_s[nan_ids] = 0
		print("DEBUG: specImg nan num is", img_s[nan_ids].shape[0])
		#########################################################
		img_s, orig_off = convolveImg(img_s, psf_img_m)
		origin_order_x = v[1] - orig_off[0]
		origin_order_y = v[2] - orig_off[1]


		specImg = galsim.ImageF(img_s)
		# photons = galsim.PhotonArray.makeFromImage(specImg)
		# photons.x += origin_order_x
		# photons.y += origin_order_y

		# xlen_imf = int(specImg.xmax - specImg.xmin + 1)
		# ylen_imf = int(specImg.ymax - specImg.ymin + 1)
		# stamp = galsim.ImageF(xlen_imf, ylen_imf)
		# stamp.wcs = local_wcs
		# stamp.setOrigin(origin_order_x, origin_order_y)

		specImg.wcs = local_wcs
		specImg.setOrigin(origin_order_x, origin_order_y)

		bounds = specImg.bounds & galsim.BoundsI(0, chip.npix_x - 1, 0, chip.npix_y - 1)
		if bounds.area() == 0:
		continue
		chip.img.setOrigin(0, 0)
		chip.img[bounds] = chip.img[bounds] + specImg[bounds]
		# stamp[bounds] = chip.img[bounds]
		# # chip.sensor.accumulate(photons, stamp)
		# chip.img[bounds] = stamp[bounds]
		chip.img.setOrigin(chip.bound.xmin, chip.bound.ymin)
		# del stamp
		del spec_orders
		return pos_shear

		def drawObj_slitless(self, tel, pos_img, psf_model, bandpass_list, filt, chip, nphotons_tot=None, g1=0, g2=0,
		exptime=150., normFilter=None, grating_split_pos=3685, fd_shear=None):

		if normFilter is not None:
		norm_thr_rang_ids = normFilter['SENSITIVITY'] > 0.001
		sedNormFactor = getNormFactorForSpecWithABMAG(ABMag=self.param['mag_use_normal'], spectrum=self.sed,
		@@ -262,22 +322,38 @@ class MockObject(object):
		xOrderSigPlus = {'A': 1.3909419820029296, 'B': 1.4760376591236062, 'C': 4.035447379743442,
		'D': 5.5684364343742825, 'E': 16.260021029735388}
		grating_split_pos_chip = 0 + grating_split_pos

		branges = np.zeros([len(bandpass_list),2])

		if hasattr(psf_model,'bandranges'):
		if psf_model.bandranges is None:
		return 2, None
		if len(psf_model.bandranges) != len(bandpass_list):
		return 2, None
		branges = psf_model.bandranges
		else:
		for i in range(len(bandpass_list)):
		bandpass = bandpass_list[i]
		psf, pos_shear = psf_model.get_PSF(chip=chip, pos_img=pos_img, bandpass=bandpass,
		folding_threshold=folding_threshold)
		branges[i, 0] = bandpass_list[i].blue_limit * 10
		branges[i, 1] = bandpass_list[i].red_limit * 10

		for i in range(len(bandpass_list)):
		# bandpass = bandpass_list[i]
		brange = branges[i]

		# psf, pos_shear = psf_model.get_PSF(chip=chip, pos_img=pos_img, bandpass=bandpass,
		# folding_threshold=folding_threshold)
		star = galsim.DeltaFunction(gsparams=gsp)
		star = star.withFlux(tel.pupil_area * exptime)
		star = galsim.Convolve(psf, star)
		psf_tmp = galsim.Gaussian(sigma=0.002)
		star = galsim.Convolve(psf_tmp, star)

		starImg = star.drawImage(nx=100, ny=100, wcs=chip_wcs_local, offset=offset)
		starImg = star.drawImage(nx=60, ny=60, wcs=chip_wcs_local, offset=offset)

		origin_star = [y_nominal - (starImg.center.y - starImg.ymin),
		x_nominal - (starImg.center.x - starImg.xmin)]
		starImg.setOrigin(0,0)
		gal_origin = [origin_star[0], origin_star[1]]
		gal_end = [origin_star[0] + starImg.array.shape[0] - 1, origin_star[1] + starImg.array.shape[1] - 1]

		if gal_origin[1] < grating_split_pos_chip < gal_end[1]:
		subSlitPos = int(grating_split_pos_chip - gal_origin[1] + 1)
		## part img disperse
		@@ -292,12 +368,15 @@ class MockObject(object):
		sdp_p1 = SpecDisperser(orig_img=star_p1, xcenter=xcenter_p1,
		ycenter=ycenter_p1, origin=origin_p1,
		tar_spec=normalSED,
		band_start=bandpass.blue_limit * 10, band_end=bandpass.red_limit * 10,
		band_start=brange[0], band_end=brange[1],
		conf=chip.sls_conf[0],
		isAlongY=0,
		flat_cube=flat_cube)

		self.addSLStoChipImage(sdp=sdp_p1, chip=chip, xOrderSigPlus=xOrderSigPlus, local_wcs=chip_wcs_local)
		# self.addSLStoChipImage(sdp=sdp_p1, chip=chip, xOrderSigPlus=xOrderSigPlus, local_wcs=chip_wcs_local)
		pos_shear=self.addSLStoChipImageWithPSF(sdp=sdp_p1, chip=chip, pos_img_local = [xcenter_p1,ycenter_p1],
		psf_model=psf_model, bandNo = i+1, grating_split_pos=grating_split_pos,
		local_wcs=chip_wcs_local, pos_img = pos_img)

		subImg_p2 = starImg.array[:, subSlitPos + 1:starImg.array.shape[1]]
		star_p2 = galsim.Image(subImg_p2)
		@@ -309,12 +388,15 @@ class MockObject(object):
		sdp_p2 = SpecDisperser(orig_img=star_p2, xcenter=xcenter_p2,
		ycenter=ycenter_p2, origin=origin_p2,
		tar_spec=normalSED,
		band_start=bandpass.blue_limit * 10, band_end=bandpass.red_limit * 10,
		band_start=brange[0], band_end=brange[1],
		conf=chip.sls_conf[1],
		isAlongY=0,
		flat_cube=flat_cube)

		self.addSLStoChipImage(sdp=sdp_p2, chip=chip, xOrderSigPlus=xOrderSigPlus, local_wcs=chip_wcs_local)
		# self.addSLStoChipImage(sdp=sdp_p2, chip=chip, xOrderSigPlus=xOrderSigPlus, local_wcs=chip_wcs_local)
		pos_shear=self.addSLStoChipImageWithPSF(sdp=sdp_p2, chip=chip, pos_img_local=[xcenter_p2, ycenter_p2],
		psf_model=psf_model, bandNo=i + 1, grating_split_pos=grating_split_pos,
		local_wcs=chip_wcs_local, pos_img = pos_img)

		del sdp_p1
		del sdp_p2
		@@ -322,23 +404,29 @@ class MockObject(object):
		sdp = SpecDisperser(orig_img=starImg, xcenter=x_nominal - 0,
		ycenter=y_nominal - 0, origin=origin_star,
		tar_spec=normalSED,
		band_start=bandpass.blue_limit * 10, band_end=bandpass.red_limit * 10,
		band_start=brange[0], band_end=brange[1],
		conf=chip.sls_conf[1],
		isAlongY=0,
		flat_cube=flat_cube)
		self.addSLStoChipImage(sdp=sdp, chip=chip, xOrderSigPlus=xOrderSigPlus, local_wcs=chip_wcs_local)
		# self.addSLStoChipImage(sdp=sdp, chip=chip, xOrderSigPlus=xOrderSigPlus, local_wcs=chip_wcs_local)
		pos_shear=self.addSLStoChipImageWithPSF(sdp=sdp, chip=chip, pos_img_local=[x_nominal, y_nominal],
		psf_model=psf_model, bandNo=i + 1, grating_split_pos=grating_split_pos,
		local_wcs=chip_wcs_local, pos_img = pos_img)
		del sdp
		elif grating_split_pos_chip >= gal_end[1]:
		sdp = SpecDisperser(orig_img=starImg, xcenter=x_nominal - 0,
		ycenter=y_nominal - 0, origin=origin_star,
		tar_spec=normalSED,
		band_start=bandpass.blue_limit * 10, band_end=bandpass.red_limit * 10,
		band_start=brange[0], band_end=brange[1],
		conf=chip.sls_conf[0],
		isAlongY=0,
		flat_cube=flat_cube)
		self.addSLStoChipImage(sdp=sdp, chip=chip, xOrderSigPlus=xOrderSigPlus, local_wcs=chip_wcs_local)
		# self.addSLStoChipImage(sdp=sdp, chip=chip, xOrderSigPlus=xOrderSigPlus, local_wcs=chip_wcs_local)
		pos_shear=self.addSLStoChipImageWithPSF(sdp=sdp, chip=chip, pos_img_local=[x_nominal, y_nominal],
		psf_model=psf_model, bandNo=i + 1, grating_split_pos=grating_split_pos,
		local_wcs=chip_wcs_local, pos_img = pos_img)
		del sdp
		del psf
		# del psf
		return 1, pos_shear

		def SNRestimate(self, img_obj, flux, noise_level=0.0, seed=31415):

ObservationSim/MockObject/SpecDisperser/SpecDisperser.py

+1 −1

Original line number	Diff line number	Diff line
		@@ -155,7 +155,7 @@ class SpecDisperser(object):
		sensitivity_beam = ysens

		len_spec_x = len(dx)
		len_spec_y = int(ceil(ytrace_beam[-1]) - floor(ytrace_beam[0]) + 1)
		len_spec_y = int(abs(ceil(ytrace_beam[-1]) - floor(ytrace_beam[0])) + 1)

		beam_sh = (self.img_sh[0] + len_spec_y, self.img_sh[1] + len_spec_x)
		modelf = zeros(product(beam_sh), dtype=float)