Merge branch 'develop' into 'master'

release version 2.1.0

See merge request csst_sim/csst-simulation!17

ObservationSim/MockObject/SpecDisperser/disperse_c/disperse.pyx

@@ -86,12 +86,12 @@ def disperse_grism_object(np.ndarray[FTYPE_t, ndim=2] flam,
                     k1 = idxl[k]+j*shg[1]+i
                     if (k1 >= 0) & (k1 < nl):
                         flat_ids = k1*nlamb+k
-                        full[k1] += fl_ij*yfrac[k]*flat_eff_all[flat_ids]
+                        full[k1] += fl_ij*(1-yfrac[k])*flat_eff_all[flat_ids]
 
-                    k2 = idxl[k]+(j-1)*shg[1]+i
+                    k2 = idxl[k]+(j+1)*shg[1]+i
                     if (k2 >= 0) & (k2 < nl):
                         flat_ids = k2*nlamb+k
-                        full[k2] += fl_ij*(1-yfrac[k])*flat_eff_all[flat_ids]
+                        full[k2] += fl_ij*yfrac[k]*flat_eff_all[flat_ids]
 
     else:
         for i in range(0-x0[1], x0[1]):
@@ -109,11 +109,11 @@ def disperse_grism_object(np.ndarray[FTYPE_t, ndim=2] flam,
                 for k in range(nk):
                     k1 = idxl[k]+j*shg[1]+i
                     if (k1 >= 0) & (k1 < nl):
-                        full[k1] += ysens[k]*fl_ij*yfrac[k]
+                        full[k1] += ysens[k]*fl_ij*(1-yfrac[k])
 
-                    k2 = idxl[k]+(j-1)*shg[1]+i
+                    k2 = idxl[k]+(j+1)*shg[1]+i
                     if (k2 >= 0) & (k2 < nl):
-                        full[k2] += ysens[k]*fl_ij*(1-yfrac[k])
+                        full[k2] += ysens[k]*fl_ij*yfrac[k]
 
     return True
 

ObservationSim/MockObject/__init__.py

@@ -4,5 +4,5 @@ from .CatalogBase import CatalogBase
 from .Quasar import Quasar
 from .Star import Star
 from .Stamp import Stamp
-from .SkybackgroundMap import *
+# from .SkybackgroundMap import *
 # from .CosmicRay import CosmicRay

ObservationSim/ObservationSim.py

@@ -14,7 +14,7 @@ from ObservationSim.Config import config_dir, ChipOutput
 from ObservationSim.Config.Header import generatePrimaryHeader, generateExtensionHeader
 from ObservationSim.Instrument import Telescope, Filter, FilterParam, FocalPlane, Chip
 from ObservationSim.Instrument.Chip import Effects
-from ObservationSim.MockObject import calculateSkyMap_split_g
+from ObservationSim.Straylight import calculateSkyMap_split_g
 from ObservationSim.PSF import PSFGauss, FieldDistortion, PSFInterp
 from ObservationSim._util import get_shear_field, makeSubDir_PointingList
 from ObservationSim.Astrometry.Astrometry_util import on_orbit_obs_position
@@ -48,7 +48,7 @@ class Observation(object):
                 self.filter_list.append(filt)
             self.all_filter.append(filt)
 
-    def run_one_chip(self, chip, filt, pointing, chip_output, wcs_fp=None, psf_model=None, shear_cat_file=None, cat_dir=None, sed_dir=None):
+    def run_one_chip(self, chip, filt, pointing, chip_output, wcs_fp=None, psf_model=None, cat_dir=None, sed_dir=None):
 
         chip_output.Log_info(':::::::::::::::::::Current Pointing Information::::::::::::::::::')
         chip_output.Log_info("RA: %f, DEC; %f" % (pointing.ra, pointing.dec))
@@ -68,8 +68,7 @@ class Observation(object):
             chip_output.Log_error("unrecognized PSF model type!!", flush=True)
 
         # Figure out shear fields
-        if shear_cat_file is not None:
-            self.g1_field, self.g2_field, self.nshear = get_shear_field(config=self.config, shear_cat_file=shear_cat_file)
+        self.g1_field, self.g2_field, self.nshear = get_shear_field(config=self.config)
 
         # Apply astrometric simulation for pointing
         if self.config["obs_setting"]["enable_astrometric_model"]:
@@ -107,6 +106,13 @@ class Observation(object):
         chip.img = galsim.ImageF(chip.npix_x, chip.npix_y)
         chip.img.setOrigin(chip.bound.xmin, chip.bound.ymin)
         chip.img.wcs = wcs_fp
+
+        if self.config["obs_setting"]["enable_straylight_model"]:
+            filt.setFilterStrayLightPixel(jtime = pointing.jdt, sat_pos = np.array([pointing.sat_x, pointing.sat_y, pointing.sat_z]), pointing_radec = np.array([pointing.ra,pointing.dec]), sun_pos = np.array([pointing.sun_x,pointing.sun_y,pointing.sun_z]))
+
+        chip_output.Log_info("========================sky pix========================")
+        chip_output.Log_info(filt.sky_background)
+
         if chip.survey_type == "photometric":
             sky_map = None
         elif chip.survey_type == "spectroscopic":
@@ -133,7 +139,8 @@ class Observation(object):
                 conf=chip.sls_conf,
                 pixelSize=chip.pix_scale,
                 isAlongY=0,
-                flat_cube=chip.flat_cube)
+                flat_cube=chip.flat_cube, zoldial_spec = filt.zodical_spec)
+            sky_map = sky_map+filt.sky_background
             del flat_normal
 
         if pointing.pointing_type == 'MS':
@@ -152,7 +159,7 @@ class Observation(object):
                     cut_filter = temp_filter
 
             if self.config["ins_effects"]["field_dist"] == True:
-                self.fd_model = FieldDistortion(chip=chip)
+                self.fd_model = FieldDistortion(chip=chip, img_rot=pointing.img_pa.deg)
             else:
                 self.fd_model = None
 
@@ -176,7 +183,12 @@ class Observation(object):
                 pixel_size=chip.pix_size,
                 xcen=chip.x_cen,
                 ycen=chip.y_cen,
-                extName='raw')
+                extName='SCI',
+                timestamp = pointing.timestamp,
+                exptime = pointing.exp_time,
+                readoutTime = 40.)
+            
+            chip_wcs = galsim.FitsWCS(header=h_ext)
 
             for j in range(self.nobj):
                 
@@ -232,12 +244,6 @@ class Observation(object):
                         obj.g1, obj.g2 = 0., 0.
                     else:
                         obj.g1, obj.g2 = self.g1_field, self.g2_field
-                elif self.config["shear_setting"]["shear_type"] == "extra":
-                    try:
-                        # [TODO]: every object with individual shear from input catalog(s)
-                        obj.g1, obj.g2 = self.g1_field[j], self.g2_field[j]
-                    except:
-                        chip_output.Log_error("failed to load external shear.")
                 elif self.config["shear_setting"]["shear_type"] == "catalog":
                     pass
                 else:
@@ -245,7 +251,7 @@ class Observation(object):
                     raise ValueError("Unknown shear input")
 
                 # Get position of object on the focal plane
-                pos_img, offset, local_wcs, real_wcs, fd_shear = obj.getPosImg_Offset_WCS(img=chip.img, fdmodel=self.fd_model, chip=chip, verbose=False, img_header=h_ext)
+                pos_img, offset, local_wcs, real_wcs, fd_shear = obj.getPosImg_Offset_WCS(img=chip.img, fdmodel=self.fd_model, chip=chip, verbose=False, chip_wcs=chip_wcs, img_header=h_ext)
 
                 # [TODO] For now, only consider objects which their centers (after field distortion) are projected within the focal plane
                 # Otherwise they will be considered missed objects
@@ -329,7 +335,7 @@ class Observation(object):
                 config=self.config, 
                 img=chip.img, 
                 chip_output=chip_output, 
-                filt=filt, 
+                filt=filt,
                 ra_cen=pointing.ra, 
                 dec_cen=pointing.dec,
                 img_rot=pointing.img_pa,
@@ -358,12 +364,36 @@ class Observation(object):
                     sat_pos=[pointing.sat_x, pointing.sat_y, pointing.sat_z],
                     sat_vel=[pointing.sat_vx, pointing.sat_vy, pointing.sat_vz],
                     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='SCI',
+                    timestamp=pointing.timestamp,
+                    exptime=pointing.exp_time,
+                    readoutTime=40.)
                 
                 chip.img = galsim.Image(chip.img.array, dtype=np.uint16)
                 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(chip.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(chip_output.subdir, h_prim['FILENAME'] + '.fits')
                 hdu1.writeto(fname, output_verify='ignore', overwrite=True)
@@ -375,7 +405,7 @@ class Observation(object):
 
         chip_output.Log_info("check running:2: pointing-%d chip-%d pid-%d memory-%6.2fGB"%(pointing.id, chip.chipID, os.getpid(), (psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024 / 1024) ))
 
-    def runExposure_MPI_PointingList(self, pointing_list, shear_cat_file=None, chips=None, use_mpi=False):
+    def runExposure_MPI_PointingList(self, pointing_list,chips=None, use_mpi=False):
         if use_mpi:
             comm = MPI.COMM_WORLD
             ind_thread = comm.Get_rank()

ObservationSim/PSF/FieldDistortion.py

 import galsim
 import numpy as np
+import cmath
 
 class FieldDistortion(object):
 
-    def __init__(self, chip, fdModel=None, fdModel_path=None):
+    def __init__(self, chip, fdModel=None, fdModel_path=None, img_rot=0.):
         if fdModel is None:
             if hasattr(chip, 'fdModel'):
                 self.fdModel = chip.fdModel
@@ -15,6 +16,7 @@ class FieldDistortion(object):
                 raise ValueError("Error: no field distortion model has been specified!")
         else:
             self.fdModel = fdModel
+        self.img_rot = img_rot
         self.ifdModel = self.fdModel["wave1"]
         self.ixfdModel = self.ifdModel["xImagePos"]
         self.iyfdModel = self.ifdModel["yImagePos"]
@@ -42,7 +44,7 @@ class FieldDistortion(object):
             return False
         return True
 
-    def get_distorted(self, chip, pos_img, bandpass=None):
+    def get_distorted(self, chip, pos_img, bandpass=None, img_rot=None):
         """ Get the distored position for an undistorted image position
 
         Parameters:
@@ -58,14 +60,14 @@ class FieldDistortion(object):
         """
         if not self.isContainObj_FD(chip=chip, pos_img=pos_img):
             return galsim.PositionD(-1, -1), None
+        if not img_rot:
+            img_rot = np.radians(self.img_rot)
+        else:
+            img_rot = np.radians(img_rot)
         x, y = pos_img.x, pos_img.y
         x = self.ixfdModel(x, y)[0][0]
         y = self.iyfdModel(x, y)[0][0]
-        ix_dx = self.ifx_dx(x, y)
-        ix_dy = self.ifx_dy(x, y)
-        iy_dx = self.ify_dx(x, y)
-        iy_dy = self.ify_dy(x, y)
-        if self.irsModel is not None:
+        if self.irsModel:
             # x1LowI, x1UpI, y1LowI, y1UpI = self.irsModel["interpLimit"]
             # if (x1LowI-x)*(x1UpI-x) <=0 and (y1LowI-y)*(y1UpI-y)<=0:
             #     dx = self.ixrsModel(x, y)[0][0]
@@ -88,8 +90,21 @@ class FieldDistortion(object):
             ix_dy = self.ifx_dy(x, y) + self.irx_dy(x, y)
             iy_dx = self.ify_dx(x, y) + self.iry_dx(x, y)
             iy_dy = self.ify_dy(x, y) + self.iry_dy(x, y)
+        else:
+            ix_dx = self.ifx_dx(x, y)
+            ix_dy = self.ifx_dy(x, y)
+            iy_dx = self.ify_dx(x, y)
+            iy_dy = self.ify_dy(x, y)
         g1k_fd   = 0.0 + (iy_dy - ix_dx) / (iy_dy + ix_dx)
         g2k_fd   = 0.0 - (iy_dx + ix_dy) / (iy_dy + ix_dx)
+
+        # [TODO] [TESTING] Rotate the shear:
+        g_abs = np.sqrt(g1k_fd**2 + g2k_fd**2)
+        phi = cmath.phase(complex(g1k_fd, g2k_fd))
+        # g_abs = 0.7
+        g1k_fd = g_abs * np.cos(phi + 2*img_rot)
+        g2k_fd = g_abs * np.sin(phi + 2*img_rot)
+
         fd_shear = galsim.Shear(g1=g1k_fd, g2=g2k_fd)
         return galsim.PositionD(x, y), fd_shear
         

ObservationSim/MockObject/SkybackgroundMap.py → ObservationSim/Straylight/SkybackgroundMap.py

@@ -7,6 +7,7 @@ from astropy.table import Table
 from scipy import interpolate
 
 import galsim
+import astropy.constants as cons
 
 import os
 
@@ -22,7 +23,7 @@ except ImportError:
 ###calculate sky map by sky SED
 
 def calculateSkyMap_split_g(skyMap=None, blueLimit=4200, redLimit=6500, skyfn='sky_emiss_hubble_50_50_A.dat', conf=[''], pixelSize=0.074, isAlongY=0,
-                            split_pos=3685, flat_cube = None):
+                            split_pos=3685, flat_cube = None, zoldial_spec = None):
     # skyMap = np.ones([yLen, xLen], dtype='float32')
     #
     # if isAlongY == 1:
@@ -44,14 +45,24 @@ def calculateSkyMap_split_g(skyMap=None, blueLimit=4200, redLimit=6500, skyfn='s
 
     fImg = galsim.Image(fimg)
     try:
-        with pkg_resources.files('ObservationSim.MockObject.data').joinpath(skyfn) as data_path:
+        with pkg_resources.files('ObservationSim.Straylight.data.sky').joinpath(skyfn) as data_path:
             skySpec = np.loadtxt(data_path)
     except AttributeError:
-        with pkg_resources.path('ObservationSim.MockObject.data', skyfn) as data_path:
+        with pkg_resources.path('ObservationSim.Straylight.data.sky', skyfn) as data_path:
             skySpec = np.loadtxt(data_path)
     # skySpec = np.loadtxt(skyfn)
     spec = Table(np.array([skySpec[:, 0], skySpec[:, 1]]).T, names=('WAVELENGTH', 'FLUX'))
 
+    if zoldial_spec is not None:
+        deltL = 0.5
+        lamb = np.arange(2000, 11000, deltL)
+
+        speci = interpolate.interp1d(zoldial_spec['WAVELENGTH'], zoldial_spec['FLUX'])
+
+        y = speci(lamb)
+        # erg/s/cm2/A --> photo/s/m2/A
+        s_flux = y * lamb / (cons.h.value * cons.c.value) * 1e-13
+        spec = Table(np.array([lamb, s_flux]).T, names=('WAVELENGTH', 'FLUX'))
     if isAlongY == 0:
         directParm = 0
     if isAlongY ==1:
@@ -266,10 +277,10 @@ def calculateSkyMap(xLen=9232, yLen=9126, blueLimit=4200, redLimit=6500,
     fimg = np.zeros_like(skyMap)
     fImg = galsim.Image(fimg)
     try:
-        with pkg_resources.files('ObservationSim.MockObject.data').joinpath(skyfn) as data_path:
+        with pkg_resources.files('ObservationSim.Straylight.data.sky').joinpath(skyfn) as data_path:
             skySpec = np.loadtxt(data_path)
     except AttributeError:
-        with pkg_resources.path('ObservationSim.MockObject.data', skyfn) as data_path:
+        with pkg_resources.path('ObservationSim.Straylight.data.sky', skyfn) as data_path:
             skySpec = np.loadtxt(data_path)
     # skySpec = np.loadtxt(skyfn)
     

ObservationSim/Straylight/Straylight.py

+import ctypes
+import numpy as np
+import astropy.constants as cons
+from scipy import interpolate
+import math
+from astropy.table import Table
+
+import astropy.coordinates as coord
+from astropy import units as u
+import sys
+
+try:
+    import importlib.resources as pkg_resources
+except ImportError:
+    # Try backported to PY<37 'importlib_resources'
+    import importlib_resources as pkg_resources
+
+filterPivotWave = {'nuv':2875.5,'u':3629.6,'g':4808.4,'r':6178.2, 'i':7609.0, 'z':9012.9,'y':9627.9}
+filterIndex = {'nuv':0,'u':1,'g':2,'r':3, 'i':4, 'z':5,'y':6}
+filterCCD = {'nuv':'UV0','u':'UV0','g':'Astro_MB','r':'Astro_MB', 'i':'Basic_NIR', 'z':'Basic_NIR','y':'Basic_NIR'}
+bandRange = {'nuv':[2504.0,3230.0],'u':[3190.0,4039.0],'g':[3989.0,5498.0],'r':[5438.0,6956.0], 'i':[6886.0,8469.0], 'z':[8379.0,10855.0],'y':[9217.0, 10900.0], 'GU':[2550, 4000],'GV':[4000, 6200],'GI':[6200,10000]}
+# Instrument_dir = '/Users/zhangxin/Work/SlitlessSim/CSST_SIM/CSST_C6/straylight/straylight/Instrument/'
+SpecOrder = ['-2','-1','0','1','2']
+
+filterMirrorEff = {'nuv':0.54,'u':0.68,'g':0.8,'r':0.8, 'i':0.8, 'z':0.8,'y':0.8}
+
+def transRaDec2D(ra, dec):
+    x1 = np.cos(dec / 57.2957795) * np.cos(ra / 57.2957795);
+    y1 = np.cos(dec / 57.2957795) * np.sin(ra / 57.2957795);
+    z1 = np.sin(dec / 57.2957795);
+    return np.array([x1, y1, z1])
+
+def getAngle132(x1 = 0, y1 = 0, z1 = 0, x2 = 0, y2 = 0, z2 = 0, x3 = 0, y3 = 0, z3 = 0):
+	
+	cosValue = 0;
+	angle = 0;
+	
+	x11 = x1-x3;
+	y11 = y1-y3;
+	z11 = z1-z3;
+	
+	x22 = x2-x3;
+	y22 = y2-y3;
+	z22 = z2-z3;
+	
+	tt = np.sqrt((x11*x11 + y11*y11 + z11* z11) * (x22*x22 + y22*y22 + z22*z22));
+	if(tt==0):
+		return 0;
+
+	cosValue = (x11*x22+y11*y22+z11*z22)/tt;
+
+	if (cosValue > 1):
+		cosValue = 1;
+	if (cosValue < -1):
+		cosValue = -1;
+	angle = math.acos(cosValue);
+	return angle * 360 / (2 * math.pi);
+
+def calculateAnglePwithEarth(sat = np.array([0,0,0]), pointing = np.array([0,0,0]), sun = np.array([0,0,0])):
+    modSat = np.sqrt(sat[0]*sat[0] + sat[1]*sat[1]+sat[2]*sat[2])
+    modPoint = np.sqrt(pointing[0]*pointing[0] + pointing[1]*pointing[1] + pointing[2]*pointing[2])
+    withLocalZenithAngle = (pointing[0] * sat[0] + pointing[1] * sat[1] + pointing[2] * sat[2]) / (modPoint*modSat)
+
+    innerM_sat_sun = sat[0] * sun[0] + sat[1] * sun[1] + sat[2] * sun[2]
+    cosAngle = innerM_sat_sun / (modSat * cons.au.value/1000)
+    isInSunSide = 1
+    if (cosAngle < -0.3385737): #cos109.79
+        isInSunSide = -1;
+    elif cosAngle >= -0.3385737 and cosAngle <= 0.3385737:
+        isInSunSide = 0;
+
+    return math.acos(withLocalZenithAngle)*180/math.pi,isInSunSide
+
+
+# /**
+#  * *eCoor = ra, *eCoor+1 = dec
+#  */
+def Cartesian2Equatorial(carCoor = np.array([0,0,0])):
+    eCoor = np.zeros(2)
+    if (carCoor[0] > 0 and carCoor[1] >= 0):
+        eCoor[0] = math.atan(carCoor[1] / carCoor[0]) * 360 / (2 * math.pi)
+    elif (carCoor[0] < 0):
+        eCoor[0] = (math.atan(carCoor[1] / carCoor[0]) + math.pi) * 360 / (2 * math.pi)
+    elif (carCoor[0] > 0 and carCoor[1] < 0):
+        eCoor[0] = (math.atan(carCoor[1] / carCoor[0]) + 2 * math.pi) * 360 / (2 * math.pi)
+    elif (carCoor[0] == 0 and carCoor[1] < 0):
+        eCoor[0] = 270
+    elif (carCoor[0] == 0 and carCoor[1] > 0):
+        eCoor[0] = 90
+    eCoor[1] = math.atan(carCoor[2] / np.sqrt(carCoor[0] * carCoor[0] + carCoor[1] * carCoor[1])) * 360 / (2 * math.pi)
+    return eCoor
+
+    
+
+class Straylight(object):
+    def __init__(self, jtime = 2460843., sat_pos = np.array([0,0,0]), pointing_radec = np.array([0,0]), sun_pos = np.array([0,0,0])):
+        self.jtime = jtime
+        self.sat = sat_pos
+        self.sun_pos = sun_pos
+        self.equator = coord.SkyCoord(pointing_radec[0]*u.degree, pointing_radec[1]*u.degree,frame='icrs')
+        self.ecliptic = self.equator.transform_to('barycentrictrueecliptic')
+        self.pointing = transRaDec2D(pointing_radec[0], pointing_radec[1])
+        platForm = sys.platform
+        if platForm == 'darwin':
+            try:
+                with pkg_resources.files('ObservationSim.Straylight.lib').joinpath('libstraylight.dylib') as dllFn:
+                    self.slcdll = ctypes.CDLL(dllFn)
+            except AttributeError:
+                with pkg_resources.path('ObservationSim.Straylight.lib', 'libstraylight.dylib') as dllFn:
+                    self.slcdll = ctypes.CDLL(dllFn)
+        elif platForm == 'linux':
+            try:
+                with pkg_resources.files('ObservationSim.Straylight.lib').joinpath('libstraylight.so') as dllFn:
+                    self.slcdll = ctypes.CDLL(dllFn)
+            except AttributeError:
+                with pkg_resources.path('ObservationSim.Straylight.lib', 'libstraylight.so') as dllFn:
+                    self.slcdll = ctypes.CDLL(dllFn)
+        # self.slcdll=ctypes.CDLL('./libstraylight.dylib')
+        self.slcdll.Calculate.argtypes = [ctypes.c_double, ctypes.POINTER(ctypes.c_double),
+                                          ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double),
+                                          ctypes.POINTER(ctypes.c_double), ctypes.c_char_p]
+
+        self.slcdll.PointSource.argtypes = [ctypes.c_double, ctypes.POINTER(ctypes.c_double),
+                                            ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double),
+                                            ctypes.POINTER(ctypes.c_double), ctypes.c_char_p]
+
+        self.slcdll.EarthShine.argtypes = [ctypes.c_double, ctypes.POINTER(ctypes.c_double),
+                                           ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double),
+                                           ctypes.POINTER(ctypes.c_double)]
+
+        self.slcdll.Zodiacal.argtypes = [ctypes.c_double, ctypes.POINTER(ctypes.c_double),
+                                         ctypes.POINTER(ctypes.c_double)]
+        self.slcdll.ComposeY.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double),
+                                         ctypes.POINTER(ctypes.c_double)]
+        self.slcdll.Init.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p]
+        try:
+            with pkg_resources.files('ObservationSim.Straylight.lib').joinpath('DE405') as tFn:
+                self.deFn = tFn.as_uri()[7:]
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Straylight.lib', 'DE405') as tFn:
+                self.deFn = tFn.as_uri()[7:]
+
+        try:
+            with pkg_resources.files('ObservationSim.Straylight.lib').joinpath('PST') as tFn:
+                self.PSTFn = tFn.as_uri()[7:]
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Straylight.lib', 'PST') as tFn:
+                self.PSTFn = tFn.as_uri()[7:]
+
+        try:
+            with pkg_resources.files('ObservationSim.Straylight.lib').joinpath('R') as tFn:
+                self.RFn = tFn.as_uri()[7:]
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Straylight.lib', 'R') as tFn:
+                self.RFn = tFn.as_uri()[7:]
+
+        try:
+            with pkg_resources.files('ObservationSim.Straylight.lib').joinpath('Zodiacal') as tFn:
+                self.ZolFn = tFn.as_uri()[7:]
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Straylight.lib', 'Zodiacal') as tFn:
+                self.ZolFn = tFn.as_uri()[7:]
+
+        try:
+            with pkg_resources.files('ObservationSim.Straylight.lib').joinpath('BrightGaia_with_csst_mag') as tFn:
+                self.brightStarTabFn = tFn.as_uri()[7:]
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Straylight.lib', 'BrightGaia_with_csst_mag') as tFn:
+                self.brightStarTabFn = tFn.as_uri()[7:]
+        print(self.deFn)
+        self.slcdll.Init(str.encode(self.deFn), str.encode(self.PSTFn), str.encode(self.RFn), str.encode(self.ZolFn))
+
+    def getFilterAndCCD_Q(self, filter = 'i'):
+        try:
+            with pkg_resources.files('ObservationSim.Instrument.data.ccd').joinpath(filterCCD[filter] + '.txt') as ccd_fn:
+                q_ccd_f = np.loadtxt(ccd_fn)
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Instrument.data.ccd', filterCCD[filter] + '.txt') as ccd_fn:
+                q_ccd_f = np.loadtxt(ccd_fn)
+
+        try:
+            with pkg_resources.files('ObservationSim.Instrument.data.filters').joinpath(filter + '.txt') as filter_fn:
+                q_fil_f = np.loadtxt(filter_fn)
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Instrument.data.filters', filter + '.txt') as filter_fn:
+                q_fil_f = np.loadtxt(filter_fn)
+
+        band_s = 2000
+        band_e = 11000
+
+        q_ccd_f[:,0] = q_ccd_f[:,0]*10
+        q_ccd = np.zeros([q_ccd_f.shape[0]+2,q_ccd_f.shape[1]])
+        q_ccd[1:-1,:] = q_ccd_f
+        q_ccd[0] = [band_s,0]
+        q_ccd[-1] = [band_e,0]
+
+        q_fil = np.zeros([q_fil_f.shape[0]+2,q_fil_f.shape[1]])
+        q_fil[1:-1,:] = q_fil_f
+        q_fil[0] = [band_s,0]
+        q_fil[-1] = [band_e,0]
+
+        
+        q_fil_i = interpolate.interp1d(q_fil[:,0], q_fil[:,1])
+        q_ccd_i = interpolate.interp1d(q_ccd[:,0], q_ccd[:,1])
+        bands = np.arange(bandRange[filter][0], bandRange[filter][1],0.5)
+        q_ccd_fil = q_fil_i(bands)*q_ccd_i(bands)
+        
+        return np.trapz(q_ccd_fil, bands)/(bandRange[filter][1]-bandRange[filter][0])
+        
+    def calculateEarthShineFilter(self, filter = 'i', pixel_size_phy = 10 ):
+        sat = (ctypes.c_double*3)()
+        sat[:] = self.sat
+        ob = (ctypes.c_double*3)()
+        ob[:]=self.pointing
+        
+        
+        py1 = (ctypes.c_double*3)()
+        py2 = (ctypes.c_double*3)()
+        self.slcdll.ComposeY(ob,py1,py2)
+
+
+        earth_e1 = (ctypes.c_double*7)()
+        self.slcdll.EarthShine(self.jtime,sat,ob,py1,earth_e1)
+        earth_e2 = (ctypes.c_double*7)()
+        self.slcdll.EarthShine(self.jtime,sat,ob,py2,earth_e2)
+        
+        band_earth_e1 = earth_e1[:][filterIndex[filter]]
+        band_earth_e2 = earth_e2[:][filterIndex[filter]]
+        
+        q=self.getFilterAndCCD_Q(filter=filter)
+        p_lambda = filterPivotWave[filter]
+        c = cons.c.value
+        h = cons.h.value
+        pix_earth_e1 = band_earth_e1/(h*c/(p_lambda*1e-10))*pixel_size_phy*1e-6*pixel_size_phy*1e-6*q
+        pix_earth_e2 = band_earth_e2/(h*c/(p_lambda*1e-10))*pixel_size_phy*1e-6*pixel_size_phy*1e-6*q
+
+        if pix_earth_e1< pix_earth_e2:
+            return pix_earth_e1, py1[:]
+        else:
+            return pix_earth_e2, py2[:]
+    
+    """
+    calculate zodiacal  call c++ program, seems to have some problem
+    """
+    def calculateZodiacalFilter1(self, filter = 'i', pixel_size_phy = 10 ):
+        sat = (ctypes.c_double*3)()
+        sat[:] = self.sat
+        ob = (ctypes.c_double*3)()
+        ob[:]=self.pointing
+    
+        zodical_e = (ctypes.c_double*7)()
+        self.slcdll.Zodiacal(self.jtime,ob,zodical_e)
+
+        ob1 = (ctypes.c_double*2)()
+        ob1[:] = np.array([self.ecliptic.lon.value, self.ecliptic.lat.value])
+        zodical_e1 = (ctypes.c_double*7)()
+        self.slcdll.Zodiacal1(ob1,zodical_e1)
+        
+        band_zodical_e = zodical_e[:][filterIndex[filter]]
+        
+        q=self.getFilterAndCCD_Q(filter=filter)
+        p_lambda = filterPivotWave[filter]
+        c = cons.c.value
+        h = cons.h.value
+        pix_zodical_e = band_zodical_e/(h*c/(p_lambda*1e-10))*pixel_size_phy*1e-6*pixel_size_phy*1e-6*q
+        
+        return pix_zodical_e, band_zodical_e
+    
+    """
+    calculate zodiacal  use python
+    """
+    def calculateZodiacalFilter2(self,filter = 'i', aper = 2, pixelsize = 0.074, sun_pos = np.array([0,0,0])):
+       
+        spec, v_mag = self.calculateZodicalSpec(longitude = self.ecliptic.lon.value, latitude = self.ecliptic.lat.value, sun_pos = sun_pos)
+        # spec = self.calculateZodicalSpec(longitude = lon, latitude = lat)
+
+        try:
+            with pkg_resources.files('ObservationSim.Instrument.data.throughputs').joinpath(filter + '_throughput.txt') as throughputFn:
+                throughput = np.loadtxt(throughputFn)
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Instrument.data.throughputs', filter + '_throughput.txt') as throughputFn:
+                throughput = np.loadtxt(throughputFn)
+
+        deltL = 0.5
+        lamb = np.arange(bandRange[filter][0], bandRange[filter][1], deltL)
+
+        speci = interpolate.interp1d(spec['WAVELENGTH'], spec['FLUX'])
+
+        y = speci(lamb)
+        # erg/s/cm2/A --> photo/s/m2/A
+        flux = y * lamb / (cons.h.value * cons.c.value) * 1e-13
+
+        throughput_i = interpolate.interp1d(throughput[:, 0], throughput[:, 1])
+
+        throughput_ = throughput_i(lamb)
+
+        sky_pix = np.trapz(flux*throughput_, lamb) * math.pi * aper*aper/4 * pixelsize * pixelsize
+
+        # sky_pix_e = np.trapz(y, lamb) * math.pi * aper*aper/4 * pixelsize * pixelsize/(10*10*1e-6*1e-6)*1e-7*1e4
+
+        return sky_pix, v_mag#,  sky_pix_e
+    
+    def calculateStarLightFilter(self, filter = 'i', pointYaxis = np.array([1,1,1]), pixel_size_phy = 10 ):
+        sat = (ctypes.c_double*3)()
+        sat[:] = self.sat
+        ob = (ctypes.c_double*3)()
+        ob[:]=self.pointing
+        
+        
+        py = (ctypes.c_double*3)()
+        py[:] = pointYaxis
+
+        q=self.getFilterAndCCD_Q(filter=filter)
+        p_lambda = filterPivotWave[filter]
+        c = cons.c.value
+        h = cons.h.value
+
+
+        star_e1 = (ctypes.c_double*7)()
+        self.slcdll.PointSource(self.jtime,sat,ob,py,star_e1, str.encode(self.brightStarTabFn))
+
+        band_star_e1 = star_e1[:][filterIndex[filter]]
+
+        pix_star_e1 = band_star_e1/(h*c/(p_lambda*1e-10))*pixel_size_phy*1e-6*pixel_size_phy*1e-6*q
+        
+        return pix_star_e1
+
+    def calculateEarthshineGrating(self, grating = 'GU', pixel_size_phy = 10, normFilter = 'g',  aper = 2, pixelsize = 0.074):
+        sat = (ctypes.c_double*3)()
+        sat[:] = self.sat
+        ob = (ctypes.c_double*3)()
+        ob[:]=self.pointing
+        
+        
+        py1 = (ctypes.c_double*3)()
+        py2 = (ctypes.c_double*3)()
+        self.slcdll.ComposeY(ob,py1,py2)
+
+
+        earth_e1 = (ctypes.c_double*7)()
+        self.slcdll.EarthShine(self.jtime,sat,ob,py1,earth_e1)
+        earth_e2 = (ctypes.c_double*7)()
+        self.slcdll.EarthShine(self.jtime,sat,ob,py2,earth_e2)
+        # zodical_e = (ctypes.c_double*7)()
+        # self.slcdll.Zodiacal(self.jtime,ob,zodical_e)
+        
+        band_earth_e1 = earth_e1[:][filterIndex[normFilter]]
+        band_earth_e2 = earth_e2[:][filterIndex[normFilter]]
+        band_earth_e = band_earth_e2
+        py = py2[:]
+        if band_earth_e1<band_earth_e2:
+            band_earth_e = band_earth_e1
+            py = py1[:]
+        # band_earth_e = np.min([band_earth_e1, band_earth_e2])
+
+        # band_earth_e1 = 0
+        # band_earth_e2 = 0
+        # band_zodical_e = zodical_e[:][filterIndex[normFilter]]
+        
+        q=self.getFilterAndCCD_Q(filter=normFilter)
+        p_lambda = filterPivotWave[normFilter]
+        c = cons.c.value
+        h = cons.h.value
+        pix_earth_e = band_earth_e/(h*c/(p_lambda*1e-10))*pixel_size_phy*1e-6*pixel_size_phy*1e-6*q
+        
+        # pix_earth_e2 = band_earth_e2/(h*c/(p_lambda*1e-10))*pixel_size_phy*1e-6*pixel_size_phy*1e-6*q
+        # pix_zodical_e = band_zodical_e/(h*c/(p_lambda*1e-10))*pixel_size_phy*1e-6*pixel_size_phy*1e-6*q
+        # pix_earth_e = np.min([pix_earth_e1, pix_earth_e2])
+
+        earthshine_v, earthshine_spec = self.calculatEarthshineByHSTSpec(filter = normFilter, aper = aper, pixelsize = pixelsize)
+
+        lamb_earth = earthshine_spec['WAVELENGTH']
+        flux_earth = earthshine_spec['FLUX']*pix_earth_e/earthshine_v
+        # print(pix_earth_e,earthshine_v)
+        earth_v_grating = 0
+        for s_order in SpecOrder:
+            try:
+                with pkg_resources.files('ObservationSim.Instrument.data.sls_conf').joinpath(
+                        grating + '.Throughput.' + s_order + 'st.fits') as thpFn:
+                    thp_ = Table.read(thpFn)
+            except AttributeError:
+                with pkg_resources.path('ObservationSim.Instrument.data.sls_conf',
+                                        grating + '.Throughput.' + s_order + 'st.fits') as thpFn:
+                    thp_ = Table.read(thpFn)
+
+            thpFn_i = interpolate.interp1d(thp_['WAVELENGTH'], thp_['SENSITIVITY'])
+            thp = thpFn_i(lamb_earth)
+            beamsEarth = np.trapz(flux_earth*thp,lamb_earth)* math.pi*aper*aper/4 * pixelsize * pixelsize
+            earth_v_grating = earth_v_grating + beamsEarth
+            # print(beamsEarth)
+
+        # print(earthshine_v, pix_earth_e, earth_v_grating)
+        return earth_v_grating, py
+
+    def calculateStarLightGrating(self, grating = 'GU', pointYaxis = np.array([1,1,1]), pixel_size_phy = 10 ):
+        sat = (ctypes.c_double*3)()
+        sat[:] = self.sat
+        ob = (ctypes.c_double*3)()
+        ob[:]=self.pointing
+        
+        
+        py = (ctypes.c_double*3)()
+        py[:] = pointYaxis
+
+        # q=self.getFilterAndCCD_Q(filter=filter)
+        # p_lambda = filterPivotWave[filter]
+        c = cons.c.value
+        h = cons.h.value
+
+
+        star_e1 = (ctypes.c_double*7)()
+        self.slcdll.PointSource(self.jtime,sat,ob,py,star_e1, str.encode(self.brightStarTabFn))
+
+        filterPivotWaveList = np.zeros(7)
+        bandRangeList = np.zeros(7)
+        filterMirrorEffList = np.zeros(7)
+        filterNameList = list(filterPivotWave.keys())
+        for i in np.arange(7):
+            filterPivotWaveList[i] = filterPivotWave[filterNameList[i]]
+            filterMirrorEffList[i] = filterMirrorEff[filterNameList[i]]
+            brange = bandRange[filterNameList[i]]
+            bandRangeList[i] = brange[1] - brange[0]
+        filterFlux_lamb = star_e1[:]/bandRangeList/filterMirrorEffList/(h*c/(filterPivotWaveList*1e-10))
+        filterFlux_lambi = interpolate.interp1d(filterPivotWaveList,filterFlux_lamb,fill_value="extrapolate")
+
+        lamb_g = np.arange(bandRange[grating][0], bandRange[grating][1],1)
+        flux_g = filterFlux_lambi(lamb_g)
+        # flux_total_g = np.trapz(flux_g,lamb_g)
+        starLight_grating = 0
+        for s_order in SpecOrder:
+            try:
+                with pkg_resources.files('ObservationSim.Instrument.data.sls_conf').joinpath(
+                        grating + '.Throughput.' + s_order + 'st.fits') as thpFn:
+                    thp_ = Table.read(thpFn)
+            except AttributeError:
+                with pkg_resources.path('ObservationSim.Instrument.data.sls_conf',
+                                        grating + '.Throughput.' + s_order + 'st.fits') as thpFn:
+                    thp_ = Table.read(thpFn)
+
+            thpFn_i = interpolate.interp1d(thp_['WAVELENGTH'], thp_['SENSITIVITY'])
+            thp = thpFn_i(lamb_g)
+            beamsZol = np.trapz(flux_g*thp,lamb_g)*pixel_size_phy*1e-6*pixel_size_phy*1e-6
+            starLight_grating = starLight_grating + beamsZol
+            # print(beamsZol)
+
+
+
+        # band_star_e1 = star_e1[:][filterIndex[filter]]
+
+        # pix_star_e1 = band_star_e1/(h*c/(p_lambda*1e-10))*pixel_size_phy*1e-6*pixel_size_phy*1e-6*q
+        
+        return starLight_grating
+
+
+    
+    def calculatEarthshineByHSTSpec(self, filter = 'g', aper = 2, pixelsize = 0.074, s = 2000, e = 11000):
+
+        try:
+            with pkg_resources.files('ObservationSim.Straylight.data.sky').joinpath('earthShine.dat') as specFn:
+                spec = np.loadtxt(specFn)
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Straylight.data.sky',
+                                    'earthShine.dat') as specFn:
+                spec = np.loadtxt(specFn)
+
+        try:
+            with pkg_resources.files('ObservationSim.Instrument.data.throughputs').joinpath(filter + '_throughput.txt') as throughputFn:
+                throughput = np.loadtxt(throughputFn)
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Instrument.data.throughputs', filter + '_throughput.txt') as throughputFn:
+                throughput = np.loadtxt(throughputFn)
+
+        deltL = 0.5
+        lamb = np.arange(bandRange[filter][0], bandRange[filter][1], deltL)
+
+        speci = interpolate.interp1d(spec[:, 0], spec[:, 1])
+        y = speci(lamb)
+        # erg/s/cm2/A --> photo/s/m2/A
+        flux = y * lamb / (cons.h.value * cons.c.value) * 1e-13
+
+        throughput_i = interpolate.interp1d(throughput[:, 0], throughput[:, 1])
+
+        throughput_ = throughput_i(lamb)
+
+        sky_pix = np.trapz(flux*throughput_, lamb) * math.pi * aper*aper/4 * pixelsize * pixelsize
+
+        lamb = np.arange(s, e, deltL)
+        speci = interpolate.interp1d(spec[:, 0], spec[:, 1])
+        y = speci(lamb)
+        # erg/s/cm2/A --> photo/s/m2/A
+        flux = y * lamb / (cons.h.value * cons.c.value) * 1e-13
+
+        return sky_pix, Table(np.array([lamb, flux]).T,names=('WAVELENGTH', 'FLUX'))
+
+    def calculateZodicalSpec(self,longitude = 50, latitude = 60, sun_pos = np.array([0,0,0])):
+        from scipy.interpolate import interp2d
+        from scipy.interpolate import griddata
+
+        try:
+            with pkg_resources.files('ObservationSim.Straylight.data').joinpath('Zodiacal_map1.dat') as z_map_fn:
+                 ZL = np.loadtxt(z_map_fn)
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Straylight.data',
+                                    'Zodiacal_map1.dat') as z_map_fn:
+                ZL = np.loadtxt(z_map_fn)
+
+        # zl_sh = ZL.shape
+        # x = np.arange(0,zl_sh[1],1)
+        # y = np.arange(0,zl_sh[0],1)
+        x = ZL[0,1:]
+        y = ZL[1:,0]
+        X,Y = np.meshgrid(x,y)
+        # f_sur = interp2d(X,Y,ZL,kind='linear')
+        sun_radec = Cartesian2Equatorial(sun_pos)
+
+        sun_eclip = coord.SkyCoord(sun_radec[0]*u.degree, sun_radec[1]*u.degree,frame='icrs')
+        sun_equtor = sun_eclip.transform_to('barycentrictrueecliptic')
+
+        longitude = longitude - (sun_equtor.lon*u.degree).value
+        longitude = np.abs(longitude)
+        # print((sun_equtor.lon*u.degree).value)
+
+        if (longitude > 180):
+            longitude = 360 - longitude
+
+        latitude = np.abs(latitude)
+        lo = longitude
+        la = latitude
+        zl = griddata((X.flatten(),Y.flatten()),ZL[1:,1:].flatten(),(la,lo), method='cubic').min()
+        zl = zl*(math.pi*math.pi)/(180*180)/(3600*3600)*1e-4*1e7*1e-8*1e-4
+        # print(zl , '\n')
+
+        try:
+            with pkg_resources.files('ObservationSim.Straylight.data.sky').joinpath('zodiacal.dat') as zodical_fn:
+                spec = np.loadtxt(zodical_fn)
+        except AttributeError:
+            with pkg_resources.path('ObservationSim.Straylight.data.sky',
+                                    'zodiacal.dat') as zodical_fn:
+                spec = np.loadtxt(zodical_fn)
+
+        speci = interpolate.interp1d(spec[:, 0], spec[:, 1])
+        flux5000 = speci(5000)
+        f_ration = zl/flux5000
+
+        v_mag = np.log10(f_ration)*(-2.5)+22.1
+        # print("factor:", v_mag, lo, la)
+
+        return Table(np.array([spec[:,0], spec[:,1]*f_ration]).T,names=('WAVELENGTH', 'FLUX')), v_mag
+    
+    def calculateStrayLightFilter(self, filter = 'i', pixel_size_phy = 10, pixel_scale = 0.074):
+        e1,py = self.calculateEarthShineFilter(filter = filter, pixel_size_phy = pixel_size_phy)
+        e2, _ = self.calculateZodiacalFilter2(filter = filter, sun_pos=self.sun_pos, pixelsize = pixel_scale)
+        e3 = self.calculateStarLightFilter(filter = filter,pointYaxis = py, pixel_size_phy = pixel_size_phy)
+        
+        return e1+e2+e3
+    
+    def calculateStrayLightGrating(self, grating = 'GI', pixel_size_phy = 10, normFilter_es = 'g'):
+        e1,py = self.calculateEarthshineGrating(grating = grating, pixel_size_phy = pixel_size_phy, normFilter = normFilter_es)
+        e2 = self.calculateStarLightGrating(grating = grating, pointYaxis = py)
+        spec, _ = self.calculateZodicalSpec(longitude = self.ecliptic.lon.value, latitude = self.ecliptic.lat.value, sun_pos = self.sun_pos)
+        
+        return e1+e2, spec
+ 
+
+def testZodiacal(lon = 285.04312526255366, lat = 30.):
+    c_eclip = coord.SkyCoord(lon*u.degree, lat*u.degree,frame='barycentrictrueecliptic')
+    c_equtor = c_eclip.transform_to('icrs')
+
+    sl = Straylight(jtime = 2459767.00354975, sat = np.array([]), radec = np.array([(c_equtor.ra*u.degree).value, (c_equtor.dec*u.degree).value]))
+    e_zol, v_mag = sl.calculateZodiacalFilter2(filter = 'i', sun_pos=np.array([-3.70939436e+07,  1.35334903e+08,  5.86673104e+07]))
+    print(e_zol)
+
+# ju=2.4608437604166665e+06
+# sat = (ctypes.c_double*3)()
+# sat[:] = np.array([5873.752, -1642.066, 2896.744])
+# ob = (ctypes.c_double*3)()
+# ob[:]=np.array([0.445256,0.76061,-0.47246])
+
+# sl = StrayLight(jtime = ju, sat = np.array([5873.752, -1642.066, 2896.744]), pointing = np.array([-0.445256,-0.76061,0.47246]))
+
+
+# fn = '/Users/zhangxin/Work/SurveyPlan/point/csst_survey_sim_20211028/E17.5_b17.5_beta_11.6_opt_transtime_1_CMG_1_dp_2_0.25_da_10_Texp_1.5_DEC60_500_0.1_800_1000_+5deg.dat'
+#
+# surveylist = np.loadtxt(fn)
+# sky_pix = np.zeros([surveylist.shape[0],7])
+#
+#
+# i = 693438
+# c_eclip = coord.SkyCoord(surveylist[:,2]*u.degree, surveylist[:,1]*u.degree,frame='barycentrictrueecliptic')
+# c_equtor = c_eclip.transform_to('icrs')
+#
+#
+# # pointing = transRaDec2D((c_equtor[i].ra*u.degree).value, (c_equtor[i].dec*u.degree).value)
+# #     # print(ju, pointing, surveylist[i,3:9])
+# # ju = surveylist[i,0]
+# # sl = StrayLight(jtime = ju, sat = surveylist[i,3:6], pointing = pointing)
+# # sl.caculateStrayLightGrating(grating = 'GI', pixel_size_phy = 10, normFilter = 'g')
+#
+# for i in np.arange(surveylist.shape[0]):
+#     print(i)
+#     if i > 300:
+#         break
+#     # if i != 300:
+#     #     continue
+#     # if i != 693438:
+#     #      continue
+#     ju = surveylist[i,0]
+#     pointing = transRaDec2D((c_equtor[i].ra*u.degree).value, (c_equtor[i].dec*u.degree).value)
+#     # print(ju, pointing, surveylist[i,3:9])
+#     sl = StrayLight(jtime = ju, sat = surveylist[i,3:6], radec = np.array([(c_equtor[i].ra*u.degree).value, (c_equtor[i].dec*u.degree).value]))
+#     # strayl_i,s_zoldical ,s_earth, s_earth1 = sl.caculateStrayLightFilter(filter = 'i')
+#     # print(i,strayl_i,s_zoldical,s_earth, s_earth1)
+#     p_cart= transRaDec2D((c_equtor[i].ra*u.degree).value, (c_equtor[i].dec*u.degree).value)
+#     sky_pix[i,6] = getAngle132(x1 = surveylist[i,6], y1 = surveylist[i,7], z1 = surveylist[i,8], x2 = p_cart[0], y2 = p_cart[1], z2 = p_cart[2], x3 = 0, y3 = 0, z3 = 0)
+#
+#     earthZenithAngle,isInSunSide = calculateAnglePwithEarth(sat = surveylist[i,3:6], pointing = pointing, sun = surveylist[i,6:9])
+#     sky_pix[i,4] = earthZenithAngle
+#     sky_pix[i,5] = isInSunSide
+#
+#     e1_,py = sl.caculateEarthShineFilter(filter = 'i')
+#     # e2, e2_ = sl.calculateZodiacalFilter1(filter = 'i')
+#     e3, v_mag = sl.calculateZodiacalFilter2(filter = 'i', sun_pos=surveylist[i,6:9])
+#     # e4 = sl.caculateStarLightFilter(filter = 'i',pointYaxis = py)
+#     # e4 = 0
+#
+#     e1,py = sl.caculateEarthshineGrating(grating = 'GI', pixel_size_phy = 10, normFilter = 'g')
+#
+#     # e2 = sl.caculateStarLightGrating(grating = 'GV', pointYaxis = py)
+#     e2 = sl.caculateStarLightGrating(grating = 'GI', pointYaxis = py)
+#     e4 = sl.caculateStarLightFilter(filter = 'i',pointYaxis = py)
+#
+#     e5=sl.caculateStrayLightFilter(filter = 'i', pixel_size_phy = 10, pixel_scale = 0.074, sun_pos = surveylist[i,6:9])
+#     e6,_=sl.caculateStrayLightGrating(grating = 'GI', normFilter_es = 'g', sun_pos = surveylist[i,6:9])
+#
+#     sky_pix[i,0] = e1
+#     sky_pix[i,1] = e2
+#     sky_pix[i,2] = e3
+#     sky_pix[i,3] = e4
+#     print(e1+e2,e1_+e3+e4,e5,e6)
+#
+#     # print(e1,e2,e3,e4)
+

ObservationSim/Straylight/__init__.py

+from .Straylight import Straylight
+from .SkybackgroundMap import *

ObservationSim/Straylight/data/Zodiacal_map1.dat

+0  0     5      10   15   20   25   30   45   60   75   90
+0  30000 150000 7000 3140 1610 985  640  275  150  100  76
+5  20000 12000	6000 2940 1540 945  625  271  150  100  76
+10 16000 8000   4740 2470 1370 865  590  264  148  100  76
+15 11500 6780   3440 1860 1110 755  525  251  146  100  76
+20 6400  4480   2410 1410 910  635  454  237  141  99   76
+25 3840  2830   1730 1100 749  545  410  223  136  97   76
+30 2480  1870   1220 845  615  467  365  207  131  95   76
+35 1650  1270   910  680  510  397  320  193  125  93   76
+40 1180  940    700  530  416  338  282  179  120  92   76
+45 910   730    555  442  356  292  250  166  116  90   76
+60 505   442    352  292  243  209  183  134  104  86   76
+75 338   317    269  227  196  172  151  116  93   82   76
+90 259   251    225  193  166  147  132  104  86   79   76
+105 212  210    197  170  150  133  119  96   82   77   76
+120 188  186    177  154  138  125  113  90   77   74   76
+135 179  178    166  147  134  122  110  90   77   73   76
+150 179  178    165  148  137  127  116  96   79   72   76
+165 196  192    179  165  151  141  131  104  82   72   76
+180 230  212    195  178  163  148  134  105  83   72   76
\ No newline at end of file

ObservationSim/Straylight/data/sky/earthShine.dat

+#A     erg/s/A/arcsec^2/cm^2
+1000 2.41e-23
+1100 4.38e-22
+1200 4.01e-23
+1300 7.41e-25
+1400 4.29e-25
+1500 4.16e-25
+1600 2.55e-25
+1700 7.89e-25
+1800 9.33e-23
+1900 4.39e-22
+2000 1.01e-21
+2100 1.6e-21
+2200 7.49e-22
+2300 3.32e-22
+2400 2.5e-22
+2500 2.39e-22
+2600 5.62e-22
+2700 6.77e-21
+2800 2.03e-21
+2900 4.32e-20
+3000 9.34e-20
+3100 2.07e-19
+3200 3.6e-19
+3300 4.27e-19
+3400 6.4e-19
+3500 8.2e-19
+3600 1.06e-18
+3700 1.22e-18
+3800 1.23e-18
+3900 1.52e-18
+4000 2.38e-18
+4250 2.38e-18
+4500 2.86e-18
+4750 2.79e-18
+5000 2.63e-18
+5250 2.67e-18
+5500 2.58e-18
+5750 2.54e-18
+6000 2.42e-18
+6250 2.26e-18
+6500 2.17e-18
+6750 2.07e-18
+7000 1.93e-18
+7250 1.85e-18
+7500 1.74e-18
+7750 1.63e-18
+8000 1.56e-18
+8250 1.48e-18
+8500 1.35e-18
+8750 1.31e-18
+9000 1.22e-18
+9250 1.15e-18
+9500 1.1e-18
+9750 1.04e-18
+10000 1e-18
+10250 9.45e-19
+10500 9.04e-19
+10750 8.41e-19
+11000 8.03e-19

ObservationSim/Straylight/data/sky/earthshine1.dat

+2000  7.69E-22
+2500  1.53E-21
+3000  1.43E-19
+3500  8.33E-19
+4000  1.66E-18
+4500  2.59E-18
+5000  2.63E-18
+5500  2.55E-18
+6000  2.42E-18
+7000  1.95E-18
+8000  1.56E-18
+9000  1.23E-18
+10000  9.97E-19
+11000  8.02E-19
+12000  6.65E-19
+13000  5.58E-19
+14000  4.70E-19
+15000  3.97E-19
+16000  3.35E-19
+17000  2.79E-19