add renamed files

observation_sim/instruments/chip/chip_utils.py

+import os
+import galsim
+import ctypes
+import numpy as np
+from astropy.io import fits
+from datetime import datetime
+
+from observation_sim.instruments.chip import effects
+from observation_sim.config.header import generatePrimaryHeader, generateExtensionHeader
+
+try:
+    import importlib.resources as pkg_resources
+except ImportError:
+    # Try backported to PY<37 'importlib_resources'
+    import importlib_resources as pkg_resources
+
+
+def log_info(msg, logger=None):
+    if logger:
+        logger.info(msg)
+    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']
+    if chipID == 2:
+        confFile = ['CSST_GV4.conf', 'CSST_GV3.conf']
+    if chipID == 3:
+        confFile = ['CSST_GU2.conf', 'CSST_GU1.conf']
+    if chipID == 4:
+        confFile = ['CSST_GU4.conf', 'CSST_GU3.conf']
+    if chipID == 5:
+        confFile = ['CSST_GV2.conf', 'CSST_GV1.conf']
+    if chipID == 10:
+        confFile = ['CSST_GI4.conf', 'CSST_GI3.conf']
+    if chipID == 21:
+        confFile = ['CSST_GI6.conf', 'CSST_GI5.conf']
+    if chipID == 26:
+        confFile = ['CSST_GV8.conf', 'CSST_GV7.conf']
+    if chipID == 27:
+        confFile = ['CSST_GU6.conf', 'CSST_GU5.conf']
+    if chipID == 28:
+        confFile = ['CSST_GU8.conf', 'CSST_GU7.conf']
+    if chipID == 29:
+        confFile = ['CSST_GV6.conf', 'CSST_GV5.conf']
+    if chipID == 30:
+        confFile = ['CSST_GI8.conf', 'CSST_GI7.conf']
+    return confFile
+
+
+def generateHeader(chip, pointing, img_type=None, img_type_code=None, project_cycle='9', run_counter='1'):
+    if (img_type is None) or (img_type_code is None):
+        img_type = pointing.pointing_type
+        img_type_code = pointing.pointing_type_code
+
+    h_prim = generatePrimaryHeader(
+        xlen=chip.npix_x,
+        ylen=chip.npix_y,
+        pointing_id=pointing.obs_id,
+        pointing_type_code=img_type_code,
+        ra=pointing.ra,
+        dec=pointing.dec,
+        pixel_scale=chip.pix_scale,
+        time_pt=pointing.timestamp,
+        exptime=pointing.exp_time,
+        im_type=img_type,
+        sat_pos=[pointing.sat_x, pointing.sat_y, pointing.sat_z],
+        sat_vel=[pointing.sat_vx, pointing.sat_vy, pointing.sat_vz],
+        project_cycle=project_cycle,
+        run_counter=run_counter,
+        chip_name=str(chip.chipID).rjust(2, '0'))
+    h_ext = generateExtensionHeader(
+        chip=chip,
+        xlen=chip.npix_x,
+        ylen=chip.npix_y,
+        ra=pointing.ra,
+        dec=pointing.dec,
+        pa=pointing.img_pa.deg,
+        gain=chip.gain,
+        readout=chip.read_noise,
+        dark=chip.dark_noise,
+        saturation=90000,
+        pixel_scale=chip.pix_scale,
+        pixel_size=chip.pix_size,
+        xcen=chip.x_cen,
+        ycen=chip.y_cen,
+        extName=img_type,
+        timestamp=pointing.timestamp,
+        exptime=pointing.exp_time,
+        readoutTime=chip.readout_time,
+        t_shutter_open=pointing.t_shutter_open,
+        t_shutter_close=pointing.t_shutter_close)
+    return h_prim, h_ext
+
+
+def output_fits_image(chip, pointing, img, output_dir, img_type=None, img_type_code=None, project_cycle='9', run_counter='1'):
+    h_prim, h_ext = generateHeader(
+        chip=chip,
+        pointing=pointing,
+        img_type=img_type,
+        img_type_code=img_type_code,
+        project_cycle=project_cycle,
+        run_counter=run_counter)
+    hdu1 = fits.PrimaryHDU(header=h_prim)
+    hdu1.add_checksum()
+    hdu1.header.comments['CHECKSUM'] = 'HDU checksum'
+    hdu1.header.comments['DATASUM'] = 'data unit checksum'
+    hdu2 = fits.ImageHDU(img.array, header=h_ext)
+    hdu2.add_checksum()
+    hdu2.header.comments['XTENSION'] = 'extension type'
+    hdu2.header.comments['CHECKSUM'] = 'HDU checksum'
+    hdu2.header.comments['DATASUM'] = 'data unit checksum'
+    hdu1 = fits.HDUList([hdu1, hdu2])
+    fname = os.path.join(output_dir, h_prim['FILENAME']+'.fits')
+    hdu1.writeto(fname, output_verify='ignore', overwrite=True)
+
+
+def add_sky_background(img, filt, exptime, sky_map=None, tel=None):
+    # Add sky background
+    if sky_map is None:
+        sky_map = filt.getSkyNoise(exptime=exptime)
+        sky_map = sky_map * np.ones_like(img.array)
+        sky_map = galsim.Image(array=sky_map)
+        # Apply Poisson noise to the sky map
+        # # (NOTE): only for photometric chips if it utilizes the photon shooting to draw stamps
+        # if self.survey_type == "photometric":
+        #     sky_map.addNoise(poisson_noise)
+    elif img.array.shape != sky_map.shape:
+        raise ValueError("The shape img and sky_map must be equal.")
+    elif tel is not None:  # If sky_map is given in flux
+        sky_map = sky_map * tel.pupil_area * exptime
+    img += sky_map
+    return img, sky_map
+
+
+def get_flat(img, seed):
+    flat_img = effects.MakeFlatSmooth(
+        GSBounds=img.bounds,
+        seed=seed)
+    flat_normal = flat_img / np.mean(flat_img.array)
+    return flat_img, flat_normal
+
+
+def add_cosmic_rays(img, chip, exptime=150, seed=0):
+    cr_map, cr_event_num = effects.produceCR_Map(
+        xLen=chip.npix_x, yLen=chip.npix_y,
+        exTime=exptime+0.5*chip.readout_time,
+        cr_pixelRatio=0.003*(exptime+0.5*chip.readout_time)/600.,
+        gain=chip.gain,
+        attachedSizes=chip.attachedSizes,
+        seed=seed)   # seed: obj-imaging:+0; bias:+1; dark:+2; flat:+3;
+    img += cr_map
+    cr_map[cr_map > 65535] = 65535
+    cr_map[cr_map < 0] = 0
+    crmap_gsimg = galsim.Image(cr_map, dtype=np.uint16)
+    del cr_map
+    return img, crmap_gsimg, cr_event_num
+
+
+def add_PRNU(img, chip, seed=0):
+    prnu_img = effects.PRNU_Img(
+        xsize=chip.npix_x,
+        ysize=chip.npix_y,
+        sigma=0.01,
+        seed=seed)
+    img *= prnu_img
+    return img, prnu_img
+
+
+def get_poisson(seed=0, sky_level=0.):
+    rng_poisson = galsim.BaseDeviate(seed)
+    poisson_noise = galsim.PoissonNoise(rng_poisson, sky_level=sky_level)
+    return rng_poisson, poisson_noise
+
+
+def get_base_img(img, chip, read_noise, readout_time, dark_noise, exptime=150., InputDark=None):
+    if InputDark == None:
+        # base_level = read_noise**2 + dark_noise*(exptime+0.5*readout_time)
+        # base_level = dark_noise*(exptime+0.5*readout_time)
+        base_level = dark_noise*(exptime)
+        base_img1 = base_level * np.ones_like(img.array)
+    else:
+        base_img1 = np.zeros_like(img.array)
+
+    ny = int(chip.npix_y/2)
+    nx = chip.npix_x
+    arr = np.arange(ny).reshape(ny, 1)
+    arr = np.broadcast_to(arr, (ny, nx))
+    base_img2 = np.zeros_like(img.array)
+    base_img2[:ny, :] = arr
+    base_img2[ny:, :] = arr[::-1, :]
+    base_img2[:, :] = base_img2[:, :]*(readout_time/ny)*dark_noise
+    return base_img1+base_img2
+
+
+def add_poisson(img, chip, exptime=150., seed=0, sky_level=0., poisson_noise=None, dark_noise=None, InputDark=None):
+    if poisson_noise is None:
+        _, poisson_noise = get_poisson(seed=seed, sky_level=sky_level)
+    read_noise = chip.read_noise
+    if dark_noise is None:
+        dark_noise = chip.dark_noise
+    base_img = get_base_img(img=img, chip=chip, read_noise=read_noise, readout_time=chip.readout_time,
+                            dark_noise=dark_noise, exptime=exptime, InputDark=InputDark)
+    img += base_img
+    img.addNoise(poisson_noise)
+    # img -= read_noise**2
+
+    if InputDark != None:
+        # "Instrument/data/dark/dark_1000s_example_0.fits"
+        hdu = fits.open(InputDark)
+        img += hdu[0].data/hdu[0].header['exptime']*exptime
+        hdu.close()
+    return img, base_img
+
+
+def add_brighter_fatter(img):
+    # Inital dynamic lib
+    try:
+        with pkg_resources.files('observation_sim.instruments.chip.libBF').joinpath("libmoduleBF.so") as lib_path:
+            lib_bf = ctypes.CDLL(lib_path)
+    except AttributeError:
+        with pkg_resources.path('observation_sim.instruments.chip.libBF', "libmoduleBF.so") as lib_path:
+            lib_bf = ctypes.CDLL(lib_path)
+    lib_bf.addEffects.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.POINTER(
+        ctypes.c_float), ctypes.POINTER(ctypes.c_float), ctypes.c_int]
+
+    # Set bit flag
+    bit_flag = 1
+    bit_flag = bit_flag | (1 << 2)
+
+    nx, ny = img.array.shape
+    nn = nx * ny
+    arr_ima = (ctypes.c_float*nn)()
+    arr_imc = (ctypes.c_float*nn)()
+
+    arr_ima[:] = img.array.reshape(nn)
+    arr_imc[:] = np.zeros(nn)
+
+    lib_bf.addEffects(nx, ny, arr_ima, arr_imc, bit_flag)
+    img.array[:, :] = np.reshape(arr_imc, [nx, ny])
+    del arr_ima, arr_imc
+    return img
+
+
+"""
+def add_inputdark(img, chip, exptime):
+    fname = "/share/home/weichengliang/CSST_git/test_new_sim/csst-simulation/ObservationSim/Instrument/data/dark/dark_1000s_example_0.fits"
+    hdu = fits.open(fname)
+    #ny, nx = img.array.shape
+    #inputdark = np.zeros([ny, nx])
+    img.array[:, :] += hdu[0].data/hdu[0].header['exptime']*exptime
+    hdu.close()
+    del inputdark
+    return img
+"""
+
+
+def AddPreScan(GSImage, pre1=27, pre2=4, over1=71, over2=80, nsecy=2, nsecx=8):
+    img = GSImage.array
+    ny, nx = img.shape
+    dx = int(nx/nsecx)
+    dy = int(ny/nsecy)
+
+    imgt = np.zeros(
+        [int(nsecy*nsecx), int(ny/nsecy+pre2+over2), int(nx/nsecx+pre1+over1)])
+    for iy in range(nsecy):
+        for ix in range(nsecx):
+            if iy % 2 == 0:
+                tx = ix
+            else:
+                tx = (nsecx-1)-ix
+            ty = iy
+            # chunk1-[1,2,3,4], chunk2-[5,6,7,8], chunk3-[9,10,11,12], chunk4-[13,14,15,16]
+            chunkidx = int(tx+ty*nsecx)
+
+            imgtemp = np.zeros(
+                [int(ny/nsecy+pre2+over2), int(nx/nsecx+pre1+over1)])
+            if int(chunkidx/4) == 0:
+                imgtemp[pre2:pre2+dy, pre1:pre1 +
+                        dx] = img[iy*dy:(iy+1)*dy, ix*dx:(ix+1)*dx]
+                imgt[chunkidx, :, :] = imgtemp
+            if int(chunkidx/4) == 1:
+                imgtemp[pre2:pre2+dy, over1:over1 +
+                        dx] = img[iy*dy:(iy+1)*dy, ix*dx:(ix+1)*dx]
+                imgt[chunkidx, :, :] = imgtemp  # [:, ::-1]
+            if int(chunkidx/4) == 2:
+                imgtemp[over2:over2+dy, over1:over1 +
+                        dx] = img[iy*dy:(iy+1)*dy, ix*dx:(ix+1)*dx]
+                imgt[chunkidx, :, :] = imgtemp  # [::-1, ::-1]
+            if int(chunkidx/4) == 3:
+                imgtemp[over2:over2+dy, pre1:pre1 +
+                        dx] = img[iy*dy:(iy+1)*dy, ix*dx:(ix+1)*dx]
+                imgt[chunkidx, :, :] = imgtemp  # [::-1, :]
+
+    # hstack chunk(1,2)-[1,2,3,4,5,6,7,8]
+    imgtx1 = np.hstack(imgt[:nsecx:, :, :])
+    # hstack chunk(4,3)-[16,15,14,13,12,11,,10,9]
+    imgtx2 = np.hstack(imgt[:(nsecx-1):-1, :, :])
+
+    newimg = galsim.Image(int(nx+(pre1+over1)*nsecx),
+                          int(ny+(pre2+over2)*nsecy), init_value=0)
+    newimg.array[:, :] = np.concatenate(
+        [imgtx1, imgtx2])  # vstack chunk(1,2) & chunk(4,3)
+
+    newimg.wcs = GSImage.wcs
+    return newimg
+
+
+def AddPreScanFO(GSImage, pre1=27, pre2=4, over1=71, over2=80, nsecy=1, nsecx=16):
+    img = GSImage.array
+    ny, nx = img.shape
+    dx = int(nx/nsecx)
+    dy = int(ny/nsecy)
+
+    newimg = galsim.Image(int(nx+(pre1+over1)*nsecx),
+                          int(ny+(pre2+over2)*nsecy), init_value=0)
+    for ix in range(nsecx):
+        newimg.array[pre2:pre2+dy, pre1+ix *
+                     (dx+pre1+over1):pre1+dx+ix*(dx+pre1+over1)] = img[0:dy, 0+ix*dx:dx+ix*dx]
+
+    newimg.wcs = GSImage.wcs
+    return newimg
+
+
+def formatOutput(GSImage, nsecy=2, nsecx=8):
+    img = GSImage.array
+    ny, nx = img.shape
+    dx = int(nx/nsecx)
+    dy = int(ny/nsecy)
+
+    imgt = np.zeros([int(nsecx*nsecy), dy, dx])
+    for iy in range(nsecy):
+        for ix in range(nsecx):
+            if iy % 2 == 0:
+                tx = ix
+            else:
+                tx = (nsecx-1)-ix
+            ty = iy
+            chunkidx = int(tx+ty*nsecx)
+            if int(chunkidx/4) == 0:
+                imgt[chunkidx, :, :] = img[iy*dy:(iy+1)*dy, ix*dx:(ix+1)*dx]
+            if int(chunkidx/4) == 1:
+                imgt[chunkidx, :, :] = img[iy*dy:(iy+1)*dy, ix*dx:(ix+1)*dx]
+            if int(chunkidx/4) == 2:
+                imgt[chunkidx, :, :] = img[iy*dy:(iy+1)*dy, ix*dx:(ix+1)*dx]
+            if int(chunkidx/4) == 3:
+                imgt[chunkidx, :, :] = img[iy*dy:(iy+1)*dy, ix*dx:(ix+1)*dx]
+
+    imgttx0 = np.hstack(imgt[0:4:, :, :])
+    imgttx1 = np.hstack(imgt[4:8:, :, ::-1])
+    imgttx2 = np.hstack(imgt[8:12:, ::-1, ::-1])
+    imgttx3 = np.hstack(imgt[12:16:, ::-1, :])
+
+    newimg = galsim.Image(int(dx*nsecx*nsecy), dy, init_value=0)
+    newimg.array[:, :] = np.hstack([imgttx0, imgttx1, imgttx2, imgttx3])
+    return newimg
+
+
+def formatRevert(GSImage, nsecy=1, nsecx=16):
+    img = GSImage.array
+    ny, nx = img.shape
+    dx = int(nx/nsecx)
+    dy = int(ny/nsecy)
+
+    newimg = galsim.Image(int(dx*8), int(dy*2), init_value=0)
+
+    for ix in range(0, 4):
+        tx = ix
+        newimg.array[0:dy, 0+tx*dx:dx+tx*dx] = img[:, 0+ix*dx:dx+ix*dx]
+    for ix in range(4, 8):
+        tx = ix
+        newimg.array[0:dy, 0+tx*dx:dx+tx *
+                     dx] = img[:, 0+ix*dx:dx+ix*dx][:, ::-1]
+    for ix in range(8, 12):
+        tx = 7-(ix-8)
+        newimg.array[0+dy:dy+dy, 0+tx*dx:dx+tx *
+                     dx] = img[:, 0+ix*dx:dx+ix*dx][::-1, ::-1]
+    for ix in range(12, 16):
+        tx = 7-(ix-8)
+        newimg.array[0+dy:dy+dy, 0+tx*dx:dx+tx *
+                     dx] = img[:, 0+ix*dx:dx+ix*dx][::-1, :]
+
+    return newimg

observation_sim/instruments/chip/libCTI/readme

+CTI_lgl_v0.3/
+
+add_CTIfinal.c >> add_CTI.c