From 11108ab68b825f2888c56dc17df99339530429e3 Mon Sep 17 00:00:00 2001 From: Astrogirlanjali Date: Tue, 6 Aug 2024 09:34:21 +1000 Subject: [PATCH 01/43] initial commit --- DREAMS/.DS_Store | Bin 0 -> 8196 bytes DREAMS/DREAMS.yaml | 52 + DREAMS/DREAMS_InGaAs.yaml | 62 + DREAMS/FPA_array_layout.dat | 23 + DREAMS/LIST_DREAMS_mirrors_static.dat | 10 + DREAMS/QE_InGaAs.dat | 2110 +++++++++++++++++++++++++ DREAMS/TER_atmosphere.dat | 359 +++++ DREAMS/TER_mirror.dat | 22 + DREAMS/default.yaml | 44 + DREAMS/filters/.DS_Store | Bin 0 -> 6148 bytes DREAMS/filters/H.dat | 367 +++++ DREAMS/filters/I.dat | 29 + DREAMS/filters/J.dat | 341 ++++ 13 files changed, 3419 insertions(+) create mode 100644 DREAMS/.DS_Store create mode 100644 DREAMS/DREAMS.yaml create mode 100644 DREAMS/DREAMS_InGaAs.yaml create mode 100644 DREAMS/FPA_array_layout.dat create mode 100644 DREAMS/LIST_DREAMS_mirrors_static.dat create mode 100644 DREAMS/QE_InGaAs.dat create mode 100644 DREAMS/TER_atmosphere.dat create mode 100644 DREAMS/TER_mirror.dat create mode 100644 DREAMS/default.yaml create mode 100644 DREAMS/filters/.DS_Store create mode 100644 DREAMS/filters/H.dat create mode 100644 DREAMS/filters/I.dat create mode 100644 DREAMS/filters/J.dat diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..fd74db0fa47d126545d750ea690613a0a551afc5 GIT binary patch literal 8196 zcmeHM&2G~`5S~o~bybQ&Ris|1EFmEdrA-J_R9w=Kf+~Robp?nY89NTGh2xE4hX_>_ zIm0{f3S4;tUI4+F*Wd)-{xou&1i=M?*ok(>-kooD=ku=Zafpc3dqIV0nTRYDp-c0q zCWz=4WlRdXG!3 z4E&c2i2H+$B6LmbfztBUfl8(T&_y&$!LfYxhqgrnbWQ7l(rAG&1%*~nrc(^2GY6*N z=&xz}fzk?2OpXjcdSs?E6s8joW=nHoHKk2$7%&WsGaz#JBCXLrg_Mrw?}dHzt$mjw zfu|^-7Ck4AdK6I#)GHjfDH_GmRt`5$4cet`wBI3T8j79Ep;jiNfKSM$OLP@uZ(=?k zRcV8oXlW70(L==YXmmz}&pF?VBfeeQp_p#L(-wSBi|T#O$1Io#B@Zp?QZhOsd;4>1 zzn^sUmy!>DCkm6aT>ioeGsP1pXRTRl-g@dB@V=9JX)mdJ-N)i=kMqbsKKA_kVXN6wcaf!+i@;Sa6N$-d=Yd6(H^3v>@V zCBGsk%!J#gvdI6pr+@$dmqIdgH4GRAev<)KY&eZNK*z6odA!KAZIovyLWJEwX$e6k k({X6|A^<)7!w|v-NNgxA_X|jDjO9wufUQ3ONJ&DY{r;mLbUpLXKv-L1%$a284D-5s zPr~jU5z+a_?oMPXA`>h_HKQZu?uM>1`5LI+<9)S1ylwY~ZKuuOblKj=vXq(ZWFyD> z2POK9=)>UR+aJrSpDCY+-$&*!c+Zz#G9MA09rg6aRAhh*kO4A41}??`?rf9EO&~QH zAOmFJhXFeu3YK9_Y=M4sK=}v&9Kr1Z+hz%?DTy_)1tJ2`C Date: Tue, 6 Aug 2024 13:31:31 +1000 Subject: [PATCH 02/43] First commit --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes DREAMS/main/.DS_Store | Bin 0 -> 6148 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 DREAMS/main/.DS_Store diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index fd74db0fa47d126545d750ea690613a0a551afc5..6dde5dd4dcd8fa84d2944b295a27489a996b9623 100644 GIT binary patch delta 300 zcmZp1XmOa}&nUSuU^hRb~Tpr;FZ1O0MVE6zunt_)gkinH9e)1yW4I7J(GHqs;_{K7s LSHyK=@gXJvP*Y2^ delta 41 xcmZp1XmOa}&nUPtU^hRb;A9>F?ak{2QkW-qi)`N<#Iu!oGrPn$mW>tc%m5&E4Z8pU diff --git a/DREAMS/main/.DS_Store b/DREAMS/main/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5220ade1c720416e9e2cae546b6e2ce94631f4d2 GIT binary patch literal 6148 zcmeHKJ5Iwu5S;}VmS|E^?gq}kJQDl!p~8m=fWx{OWp>LWXeNCixKkM(LgziT(!QRVS~ zax1xzl|0C9$iI5-=QeHAEY|G;vHJ0_e|x`ty&mS5Kjydh{b&0Cl|}`q02QDDRN!AK zfS#>ZpE+`+0#twsd@G>ehYVLNft{m$I}1?0PEIkQBs(4PY~_-QBUdUw1%?Wo`gWrI{|0_!{vVRKqXJam zPbrY9X5P&3O3_gW!*AhVhFUAfVyzfxtr#0^#pk`ctk=kwz|PU=h#MWq9|6^c JMg@LDflqG#D%Jo1 literal 0 HcmV?d00001 From 84ec5ba10faf9d23685870d67de004f85b41067f Mon Sep 17 00:00:00 2001 From: Astrogirlanjali Date: Wed, 7 Aug 2024 09:36:01 +1000 Subject: [PATCH 03/43] filter is added --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes DREAMS/Test_codes/.DS_Store | Bin 0 -> 6148 bytes DREAMS/Test_codes/LMC.py | 75 +++++++++++++++++++ DREAMS/Test_codes/gal.py | 85 ++++++++++++++++++++++ DREAMS/Test_codes/star_1.py | 84 ++++++++++++++++++++++ DREAMS/Test_codes/testt.py | 140 ++++++++++++++++++++++++++++++++++++ DREAMS/default.yaml | 4 +- DREAMS/main/.DS_Store | Bin 6148 -> 6148 bytes 8 files changed, 386 insertions(+), 2 deletions(-) create mode 100644 DREAMS/Test_codes/.DS_Store create mode 100644 DREAMS/Test_codes/LMC.py create mode 100644 DREAMS/Test_codes/gal.py create mode 100644 DREAMS/Test_codes/star_1.py create mode 100644 DREAMS/Test_codes/testt.py diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index 6dde5dd4dcd8fa84d2944b295a27489a996b9623..d4e02e517dd878568202c809dd80871328d9b9e7 100644 GIT binary patch delta 682 zcmZp1XmOa}UDU^hRb;$$8HC#KUHlLG`K*dDT~spK0@&J&P=G5Z9hnOGb)uNEj| z7Vyl;Pfp6oPhwzT5MW?n{5hFLM3tG*P++o-hy;t5i{$mm9wIUjMuvzi6SKnPc9DJV zTnr%$sSL#oB@FQl$qe}nDIgxIQ4C%{*S;x1}Ep|7BGN;T?>$6VaR1jWXNR5%guLjNy^Dj0*Z00`8@T??O){~>>w;v>K95~E-s82DohNN0RH9`U2{+4|-4^sG&6 tXKX5J*Qi3F-ns;Ep!>*7YzIW18-#6Q2_t| literal 0 HcmV?d00001 diff --git a/DREAMS/Test_codes/LMC.py b/DREAMS/Test_codes/LMC.py new file mode 100644 index 00000000..4fc2fcf1 --- /dev/null +++ b/DREAMS/Test_codes/LMC.py @@ -0,0 +1,75 @@ +#cluster in the LMC +import os +import pytest +import numpy as np +from astropy.io.fits import HDUList +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +import scopesim +import synphot +from scopesim import Source +from astropy.io import fits + + +from scopesim import rc +from scopesim.source.source_templates import star_field +import scopesim_templates as sim_tp +from scopesim.optics.fov_manager import FOVManager + +PLOTS = True + +if rc.__config__["!SIM.tests.run_integration_tests"] is False: + pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") + +# Set TOP_PATH to the directory containing the DREAMS package +TOP_PATH = "/Users/anjali/Desktop" +rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH + +# Adjust the PKGS dictionary to reflect the correct path +PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} + +# Verify the path to the DREAMS package +if not os.path.exists(PKGS["DREAMS"]): + raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") +else: + print("DREAMS package found at:", PKGS["DREAMS"]) + +cmds = scopesim.UserCommands(use_instrument="DREAMS") +cmds["!OBS.dit"] = 1000 +cmds["!OBS.ndit"] = 1000 +cmds["!DET.bin_size"] = 1 +cmds["!OBS.sky.bg_mag"] = 14.9 +cmds["!OBS.sky.filter_name"] = "J" +cmds["SIM.sub_pixel.flag"] = True +dreams = scopesim.OpticalTrain(cmds) +dreams["detector_linearity"].include = False +dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) +# Then make the initial field of view 10 times larges than normal. +dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec +dreams.fov_manager.volumes_list[0]["x_max"] = 18000 +dreams.fov_manager.volumes_list[0]["y_min"] = -18000 +dreams.fov_manager.volumes_list[0]["y_max"] = 18000 +# Finally, shrink the field of view to the detector size. +dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) + +print("scopesim package loaded successfully.") +src = sim_tp.stellar.clusters.cluster(mass=1000, distance=50000, core_radius=500, seed=9002) + +dreams.observe(src, update=False) +print("yessss anjali") +hdus = dreams.readout() +#dreams.readout(filename="Han.fits") +plt.subplot(121) +wave = np.arange(3000, 11000) +plt.plot(wave, dreams.optics_manager.surfaces_table.throughput(wave)) +plt.subplot(122) +im = hdus[0][1].data +# detector_order = [2, 1, 4, 3, 6, 5] +detector_order = [1, 2, 3, 4, 5, 6] +plt.figure(figsize=(20, 20)) +for plot_number, hdu_number in enumerate(detector_order, 1): + plt.subplot(3, 2, plot_number) + plt.imshow(hdus[0][hdu_number].data, norm=LogNorm(), cmap="hot") + plt.colorbar() + +plt.show() diff --git a/DREAMS/Test_codes/gal.py b/DREAMS/Test_codes/gal.py new file mode 100644 index 00000000..98a93f85 --- /dev/null +++ b/DREAMS/Test_codes/gal.py @@ -0,0 +1,85 @@ +import os +import pytest +import numpy as np +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +import scopesim +from scopesim import Source, rc +from scopesim_templates.extragalactic import galaxy +from scopesim.source.source_templates import star_field +from scopesim.optics.fov_manager import FOVManager +from astropy.io import fits + +PLOTS = True + +# Check if integration tests should be skipped +if rc.__config__["!SIM.tests.run_integration_tests"] is False: + pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") + +# Set TOP_PATH to the directory containing the DREAMS package +TOP_PATH = "/Users/anjali/Desktop" +rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH + +# Adjust the PKGS dictionary to reflect the correct path +PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} + +# Verify the path to the DREAMS package +if not os.path.exists(PKGS["DREAMS"]): + raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") +else: + print("DREAMS package found at:", PKGS["DREAMS"]) + +# Initialize UserCommands for DREAMS +cmds = scopesim.UserCommands(use_instrument="DREAMS") +cmds["!OBS.dit"] = 10 +cmds["!DET.bin_size"] = 1 +cmds["!OBS.sky.bg_mag"] = 14.9 +cmds["!OBS.sky.filter_name"] = "J" +cmds["SIM.sub_pixel.flag"] = True + +# Set up the optical train +dreams = scopesim.OpticalTrain(cmds) +dreams["detector_linearity"].include = False + +# Configure the field of view +dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) +dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec +dreams.fov_manager.volumes_list[0]["x_max"] = 18000 +dreams.fov_manager.volumes_list[0]["y_min"] = -18000 +dreams.fov_manager.volumes_list[0]["y_max"] = 18000 +dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) + +print("scopesim package loaded successfully.") + +# Create a galaxy source +src = galaxy("kc96/s0", z=0.1, amplitude=17, filter_curve="J", pixel_scale=0.05, r_eff=2.5, n=4, ellip=0.5, theta=45, extend=3) + +# Observe the source +dreams.observe(src, update=False) + +# Readout and plot +hdus = dreams.readout() + +plt.subplot(121) +wave = np.arange(3000, 11000) +plt.plot(wave, dreams.optics_manager.surfaces_table.throughput(wave)) + +plt.subplot(122) +im = hdus[0][1].data +plt.imshow(im, norm=LogNorm()) +plt.colorbar() +plt.title("Observed Galaxy Field") +plt.xlabel("X Pixels") +plt.ylabel("Y Pixels") + +detector_order = [2, 1, 4, 3, 6, 5] +plt.figure(figsize=(20, 20)) +for plot_number, hdu_number in enumerate(detector_order, 1): + plt.subplot(3, 2, plot_number) + plt.imshow(np.log10(src.fields[0].data), origin="lower") + plt.colorbar() + plt.title(f"HDU {hdu_number}") + +plt.show() + + diff --git a/DREAMS/Test_codes/star_1.py b/DREAMS/Test_codes/star_1.py new file mode 100644 index 00000000..c6497145 --- /dev/null +++ b/DREAMS/Test_codes/star_1.py @@ -0,0 +1,84 @@ +import os +import pytest +import numpy as np +from astropy.io.fits import HDUList +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +import scopesim +import synphot +from scopesim import Source +from astropy.io import fits + + +from scopesim import rc +from scopesim.source.source_templates import star_field +import scopesim_templates as sim_tp +from scopesim.optics.fov_manager import FOVManager + +PLOTS = True + +if rc.__config__["!SIM.tests.run_integration_tests"] is False: + pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") + +# Set TOP_PATH to the directory containing the DREAMS package +TOP_PATH = "/Users/anjali/Desktop" +rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH + +# Adjust the PKGS dictionary to reflect the correct path +PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} + +# Verify the path to the DREAMS package +if not os.path.exists(PKGS["DREAMS"]): + raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") +else: + print("DREAMS package found at:", PKGS["DREAMS"]) + +cmds = scopesim.UserCommands(use_instrument="DREAMS") +cmds["!OBS.dit"] = 10 +cmds["!DET.bin_size"] = 1 +cmds["!OBS.sky.bg_mag"] = 14.9 +cmds["!OBS.sky.filter_name"] = "J" +cmds["SIM.sub_pixel.flag"] = True +dreams = scopesim.OpticalTrain(cmds) +dreams["detector_linearity"].include = False +dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) +# Then make the initial field of view 10 times larges than normal. +dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec +dreams.fov_manager.volumes_list[0]["x_max"] = 18000 +dreams.fov_manager.volumes_list[0]["y_min"] = -18000 +dreams.fov_manager.volumes_list[0]["y_max"] = 18000 +# Finally, shrink the field of view to the detector size. +dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) + +print("scopesim package loaded successfully.") +x, y = np.meshgrid(np.arange(100), np.arange(100)) +img = np.exp(-1 * ( ( (x - 50) / 5)**2 + ( (y - 50) / 5)**2 ) ) +# Fits headers of the image. Yes it needs a WCS +hdr = fits.Header(dict(NAXIS=2,NAXIS1=img.shape[0]+1,NAXIS2=img.shape[1]+1, CRPIX1=img.shape[0] / 2, CRPIX2=img.shape[1] / 2, CRVAL1=0, CRVAL2=0, CDELT1=0.2/3600, CDELT2=0.2/3600, +CUNIT1="DEG", CUNIT2="DEG", CTYPE1='RA---TAN', CTYPE2='DEC--TAN')) +# Creating an ImageHDU object +hdu = fits.ImageHDU(data=img, header=hdr) + +# Creating of a black body spectrum +wave = np.arange(1000, 35000, 10 ) +bb = synphot.models.BlackBody1D(temperature=5000) +sp = synphot.SourceSpectrum(synphot.Empirical1D, points=wave, lookup_table=bb(wave)) +src = Source(image_hdu=hdu, spectra=sp) +src.shift(10, 10) +dreams.observe(src, update=False) +print("yessss anjali") +hdus = dreams.readout() +#dreams.readout(filename="Han.fits") +plt.subplot(121) +wave = np.arange(3000, 11000) +plt.plot(wave, dreams.optics_manager.surfaces_table.throughput(wave)) +plt.subplot(122) +im = hdus[0][1].data +detector_order = [2, 1, 4, 3, 6, 5] +plt.figure(figsize=(20, 20)) +for plot_number, hdu_number in enumerate(detector_order, 1): + plt.subplot(3, 2, plot_number) + plt.imshow(hdus[0][hdu_number].data, origin="lower", norm=LogNorm()) + plt.colorbar() + +plt.show() diff --git a/DREAMS/Test_codes/testt.py b/DREAMS/Test_codes/testt.py new file mode 100644 index 00000000..4acce217 --- /dev/null +++ b/DREAMS/Test_codes/testt.py @@ -0,0 +1,140 @@ +import os +import pytest +import numpy as np +from astropy.io.fits import HDUList +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +import scopesim + +from scopesim import rc +from scopesim.source.source_templates import star_field +import scopesim_templates as sim_tp +from scopesim.optics.fov_manager import FOVManager + +PLOTS = True + +if rc.__config__["!SIM.tests.run_integration_tests"] is False: + pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") + +# Set TOP_PATH to the directory containing the DREAMS package +TOP_PATH = "/Users/anjali/Desktop" +rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH + +# Adjust the PKGS dictionary to reflect the correct path +PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} + +# Verify the path to the DREAMS package +if not os.path.exists(PKGS["DREAMS"]): + raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") +else: + print("DREAMS package found at:", PKGS["DREAMS"]) + +class TestLoads: + def test_scopesim_loads_package(self): + dreams = scopesim.OpticalTrain("DREAMS") + assert isinstance(dreams, scopesim.OpticalTrain) # Corrected syntax + print("scopesim package loaded successfully.") + +class TestObserves: + def test_something_comes_out(self): + print("Starting observation test...") + + # Setting the width to 10000 arcsec makes the field fill the image. + # A with of 700 works as well, but covers only a fraction of the + # middle two detectors. + src = star_field(10000, 10, 20, width=10000) + + cmds = scopesim.UserCommands(use_instrument="DREAMS") + cmds["!OBS.dit"] = 8 + cmds["!DET.bin_size"] = 1 + cmds["!OBS.sky.bg_mag"] = 14.9 + cmds["!OBS.sky.filter_name"] = "J" + cmds["SIM.sub_pixel.flag"] = True + + dreams = scopesim.OpticalTrain(cmds) + dreams["detector_linearity"].include = False + + # Hackish workaround to get a larger Field of View. + # This problem is fixed in https://github.com/AstarVienna/ScopeSim/pull/433 + # This hack can thus be removed once that is merged and a new + # ScopeSim version is released. + # First recreate the fov_manager without preloading the field of + # views with the wrong values. + dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) + # Then make the initial field of view 10 times larges than normal. + dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec + dreams.fov_manager.volumes_list[0]["x_max"] = 18000 + dreams.fov_manager.volumes_list[0]["y_min"] = -18000 + dreams.fov_manager.volumes_list[0]["y_max"] = 18000 + # Finally, shrink the field of view to the detector size. + dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) + + # We now need to put update=False here, because otherwise the hacked + # fov_manager gets reinitialized. dreams can therefor only be used + # once, and needs to be recreated for the next simulation. + dreams.observe(src, update=False) + + hdus = dreams.readout("dreams.fits") + + print(f"Observation completed. HDUList type: {type(hdus[0])}") + + if PLOTS: + plt.subplot(121) + wave = np.arange(3000, 11000) + plt.plot(wave, dreams.optics_manager.surfaces_table.throughput(wave)) + + plt.subplot(122) + im = hdus[0][1].data + plt.imshow(im, norm=LogNorm()) + plt.colorbar() + plt.title("Observed Star Field") + plt.xlabel("X Pixels") + plt.ylabel("Y Pixels") + plt.grid() + plt.show() + + #detector_order = [2, 1, 4, 3, 6, 5] + #plt.figure(figsize=(20, 20)) + #for plot_number, hdu_number in enumerate(detector_order, 1): + #plt.subplot(3, 2, plot_number) + #plt.imshow(hdus[0][hdu_number].data, origin="lower", norm=LogNorm()) + #plt.colorbar() + #plt.show() + + @pytest.mark.slow + def test_observes_from_scopesim_templates(self): + print("Starting scopesim templates observation test...") + src = sim_tp.stellar.cluster(mass=10000, distance=2000, core_radius=1) + + dreams = scopesim.OpticalTrain("DREAMS") + dreams.observe(src) + + dreams.cmds["!OBS.dit"] = 10 + hdus = dreams.readout() + + assert isinstance(hdus[0], HDUList) + print("Observation from scopesim templates completed.") + + if PLOTS: + im = hdus[0][1].data + plt.imshow(im, norm=LogNorm(), cmap="hot") + plt.colorbar() + plt.show() + + @pytest.mark.slow + def test_saves_readout_to_disc(self): + print("Starting test to save readout to disk...") + src = sim_tp.stellar.cluster(mass=10000, distance=2000, core_radius=1) + dreams = scopesim.OpticalTrain("DREAMS") + dreams.observe(src) + dreams.readout(filename="GNANU.fits") + + assert os.path.exists("GNANU.fits") + print("Readout saved to GNANU.fits.") + +def run_test_and_plot(): + test_observes = TestObserves() + test_observes.test_something_comes_out() + +# Run the test and plot as soon as the module is imported +run_test_and_plot() diff --git a/DREAMS/default.yaml b/DREAMS/default.yaml index 9334d6a4..56bb6574 100644 --- a/DREAMS/default.yaml +++ b/DREAMS/default.yaml @@ -19,10 +19,10 @@ properties : pupil_angle : 0 dit : 10 ndit : 1 - filter_name : "!OBS.filter_name" + filter_name : !OBS.filter_name sky : bg_mag : 14.5 - filter_name : "!OBS.filter_name" + filter_name : !OBS.filter_name --- ### default simulation parameters needed for DREAMS simulation diff --git a/DREAMS/main/.DS_Store b/DREAMS/main/.DS_Store index 5220ade1c720416e9e2cae546b6e2ce94631f4d2..d5c8125a2924fecedca65e0215b7b21fe2899637 100644 GIT binary patch delta 113 zcmZoMXfc?uG?r14hk=2Cg+Y%YogtH;M1& delta 114 zcmZoMXfc?uG>*Zpg@J*Ag+Y%YogtH Date: Wed, 7 Aug 2024 09:43:32 +1000 Subject: [PATCH 04/43] changes --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes DREAMS/DREAMS.yaml | 4 ++-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index d4e02e517dd878568202c809dd80871328d9b9e7..5a1b0f12fff3c72cd80a7e8c93a7b007d349dfb8 100644 GIT binary patch delta 99 zcmZp1XmOa}I9U^hRb(qtY1C#D}uCI<*eu%;id;VPS)D=NHtHb;uCW183y2>?8q7o-3H diff --git a/DREAMS/DREAMS.yaml b/DREAMS/DREAMS.yaml index 4ab2d79e..0bf83cca 100644 --- a/DREAMS/DREAMS.yaml +++ b/DREAMS/DREAMS.yaml @@ -26,9 +26,9 @@ effects: kwargs : filename: "TER_atmosphere.dat" rescale_emission: - filter_name: "!OBS.sky.filter_name" + filter_name: "!OBS.filter_name" filename_format: "filters/{}.dat" - value: "!OBS.sky.bg_mag" + value: "!OBS.bg_mag" unit: mag - name: dreams_static_surfaces description : telescope and camera optical surfaces From b65cb6be31b5736d9e4b8962a7d2fe9a8cb58ce7 Mon Sep 17 00:00:00 2001 From: Astrogirlanjali Date: Wed, 7 Aug 2024 09:47:16 +1000 Subject: [PATCH 05/43] Added crowed field examples --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes DREAMS/Test_codes/.DS_Store | Bin 6148 -> 6148 bytes DREAMS/Test_codes/field.ipynb | 624 ++++++++++++++++++++++++++++++++++ 3 files changed, 624 insertions(+) create mode 100644 DREAMS/Test_codes/field.ipynb diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index 5a1b0f12fff3c72cd80a7e8c93a7b007d349dfb8..062e9c3ef5121fa2021b655240078459e868019e 100644 GIT binary patch delta 74 zcmZp1XmQx!E5OXeP(C?8K!Ro4=_OHB)qu~2NHo}wrl0|Nsi1A_nqLkfc)LncE3LnTArW=5vvjOHLIZiY0V zU@AinvNS`IXHI@{QcivnPz6vY;~OAt@E-~`^DrJ|-OSFx&jGXrXwrA)$^0Ug96(Ee Mh=E~qfXEhR0I!4}z5oCK delta 82 zcmZoMXfc=|#>B`mu~2NHo}wr#0|Nsi1A_nqLjgmjXHI@{Qcix-#KPr_tec&fjJq^K diff --git a/DREAMS/Test_codes/field.ipynb b/DREAMS/Test_codes/field.ipynb new file mode 100644 index 00000000..f082fb55 --- /dev/null +++ b/DREAMS/Test_codes/field.ipynb @@ -0,0 +1,624 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "LKOlMK9pT1wu", + "outputId": "892bca39-8580-4249-8579-7a5161b33618" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: scopesim_templates in /usr/local/lib/python3.10/dist-packages (0.5.2)\n", + "Requirement already satisfied: numpy>=1.26.3 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (1.13.1)\n", + "Requirement already satisfied: astropy>=5.3.3 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (5.3.4)\n", + "Requirement already satisfied: matplotlib>=3.7.2 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (3.9.0)\n", + "Requirement already satisfied: docutils>=0.19 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (0.19)\n", + "Requirement already satisfied: beautifulsoup4>=4.12.1 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (4.12.3)\n", + "Requirement already satisfied: lxml>=4.9.3 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (4.9.4)\n", + "Requirement already satisfied: pyyaml>=6.0.1 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (6.0.1)\n", + "Requirement already satisfied: synphot>=1.2.1 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (1.3.post0)\n", + "Requirement already satisfied: scopesim>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (0.8.3)\n", + "Requirement already satisfied: pyckles>=0.2 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (0.2)\n", + "Requirement already satisfied: spextra>=0.40.0 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (0.40.0)\n", + "Requirement already satisfied: astar-utils>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from scopesim_templates) (0.2.2)\n", + "Requirement already satisfied: colorama<0.5.0,>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from astar-utils>=0.2.1->scopesim_templates) (0.4.6)\n", + "Requirement already satisfied: more-itertools<11.0.0,>=10.1.0 in /usr/local/lib/python3.10/dist-packages (from astar-utils>=0.2.1->scopesim_templates) (10.3.0)\n", + "Requirement already satisfied: pyerfa>=2.0 in /usr/local/lib/python3.10/dist-packages (from astropy>=5.3.3->scopesim_templates) (2.0.1.4)\n", + "Requirement already satisfied: packaging>=19.0 in /usr/local/lib/python3.10/dist-packages (from astropy>=5.3.3->scopesim_templates) (24.1)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.10/dist-packages (from beautifulsoup4>=4.12.1->scopesim_templates) (2.5)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.7.2->scopesim_templates) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.7.2->scopesim_templates) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.7.2->scopesim_templates) (4.53.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.7.2->scopesim_templates) (1.4.5)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.7.2->scopesim_templates) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.7.2->scopesim_templates) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.7.2->scopesim_templates) (2.8.2)\n", + "Requirement already satisfied: anisocado>=0.3.0 in /usr/local/lib/python3.10/dist-packages (from scopesim>=0.7.0->scopesim_templates) (0.3.0)\n", + "Requirement already satisfied: httpx<0.24.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from scopesim>=0.7.0->scopesim_templates) (0.23.3)\n", + "Requirement already satisfied: pooch<2.0.0,>=1.7.0 in /usr/local/lib/python3.10/dist-packages (from scopesim>=0.7.0->scopesim_templates) (1.8.2)\n", + "Requirement already satisfied: skycalc_ipy>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from scopesim>=0.7.0->scopesim_templates) (0.4.0)\n", + "Requirement already satisfied: tqdm<5.0.0,>=4.66.1 in /usr/local/lib/python3.10/dist-packages (from scopesim>=0.7.0->scopesim_templates) (4.66.4)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx<0.24.0,>=0.23.0->scopesim>=0.7.0->scopesim_templates) (2024.7.4)\n", + "Requirement already satisfied: httpcore<0.17.0,>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from httpx<0.24.0,>=0.23.0->scopesim>=0.7.0->scopesim_templates) (0.16.3)\n", + "Requirement already satisfied: rfc3986<2,>=1.3 in /usr/local/lib/python3.10/dist-packages (from rfc3986[idna2008]<2,>=1.3->httpx<0.24.0,>=0.23.0->scopesim>=0.7.0->scopesim_templates) (1.5.0)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx<0.24.0,>=0.23.0->scopesim>=0.7.0->scopesim_templates) (1.3.1)\n", + "Requirement already satisfied: platformdirs>=2.5.0 in /usr/local/lib/python3.10/dist-packages (from pooch<2.0.0,>=1.7.0->scopesim>=0.7.0->scopesim_templates) (4.2.2)\n", + "Requirement already satisfied: requests>=2.19.0 in /usr/local/lib/python3.10/dist-packages (from pooch<2.0.0,>=1.7.0->scopesim>=0.7.0->scopesim_templates) (2.31.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib>=3.7.2->scopesim_templates) (1.16.0)\n", + "Requirement already satisfied: h11<0.15,>=0.13 in /usr/local/lib/python3.10/dist-packages (from httpcore<0.17.0,>=0.15.0->httpx<0.24.0,>=0.23.0->scopesim>=0.7.0->scopesim_templates) (0.14.0)\n", + "Requirement already satisfied: anyio<5.0,>=3.0 in /usr/local/lib/python3.10/dist-packages (from httpcore<0.17.0,>=0.15.0->httpx<0.24.0,>=0.23.0->scopesim>=0.7.0->scopesim_templates) (3.7.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->pooch<2.0.0,>=1.7.0->scopesim>=0.7.0->scopesim_templates) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->pooch<2.0.0,>=1.7.0->scopesim>=0.7.0->scopesim_templates) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->pooch<2.0.0,>=1.7.0->scopesim>=0.7.0->scopesim_templates) (2.0.7)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio<5.0,>=3.0->httpcore<0.17.0,>=0.15.0->httpx<0.24.0,>=0.23.0->scopesim>=0.7.0->scopesim_templates) (1.2.2)\n" + ] + } + ], + "source": [ + "pip install scopesim_templates\n" + ] + }, + { + "cell_type": "code", + "source": [ + "pip install scopesim" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1wn595XLT2_R", + "outputId": "e64bbff0-3d68-4610-caad-54f1e852eca9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: scopesim in /usr/local/lib/python3.10/dist-packages (0.8.3)\n", + "Requirement already satisfied: anisocado>=0.3.0 in /usr/local/lib/python3.10/dist-packages (from scopesim) (0.3.0)\n", + "Requirement already satisfied: astar-utils>=0.2.2 in /usr/local/lib/python3.10/dist-packages (from scopesim) (0.2.2)\n", + "Requirement already satisfied: astropy<6.0.0,>=5.3.4 in /usr/local/lib/python3.10/dist-packages (from scopesim) (5.3.4)\n", + "Requirement already satisfied: beautifulsoup4<5.0.0,>=4.12.1 in /usr/local/lib/python3.10/dist-packages (from scopesim) (4.12.3)\n", + "Requirement already satisfied: docutils<0.20,>=0.19 in /usr/local/lib/python3.10/dist-packages (from scopesim) (0.19)\n", + "Requirement already satisfied: httpx<0.24.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from scopesim) (0.23.3)\n", + "Requirement already satisfied: lxml<5.0.0,>=4.9.3 in /usr/local/lib/python3.10/dist-packages (from scopesim) (4.9.4)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.7.2 in /usr/local/lib/python3.10/dist-packages (from scopesim) (3.9.0)\n", + "Requirement already satisfied: more-itertools<11.0.0,>=10.1.0 in /usr/local/lib/python3.10/dist-packages (from scopesim) (10.3.0)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.26.3 in /usr/local/lib/python3.10/dist-packages (from scopesim) (1.26.4)\n", + "Requirement already satisfied: pooch<2.0.0,>=1.7.0 in /usr/local/lib/python3.10/dist-packages (from scopesim) (1.8.2)\n", + "Requirement already satisfied: pyyaml<7.0.0,>=6.0.1 in /usr/local/lib/python3.10/dist-packages (from scopesim) (6.0.1)\n", + "Requirement already satisfied: scipy<2.0.0,>=1.11.4 in /usr/local/lib/python3.10/dist-packages (from scopesim) (1.13.1)\n", + "Requirement already satisfied: skycalc_ipy>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from scopesim) (0.4.0)\n", + "Requirement already satisfied: synphot<2.0.0,>=1.2.1 in /usr/local/lib/python3.10/dist-packages (from scopesim) (1.3.post0)\n", + "Requirement already satisfied: tqdm<5.0.0,>=4.66.1 in /usr/local/lib/python3.10/dist-packages (from scopesim) (4.66.4)\n", + "Requirement already satisfied: colorama<0.5.0,>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from astar-utils>=0.2.2->scopesim) (0.4.6)\n", + "Requirement already satisfied: pyerfa>=2.0 in /usr/local/lib/python3.10/dist-packages (from astropy<6.0.0,>=5.3.4->scopesim) (2.0.1.4)\n", + "Requirement already satisfied: packaging>=19.0 in /usr/local/lib/python3.10/dist-packages (from astropy<6.0.0,>=5.3.4->scopesim) (24.1)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.10/dist-packages (from beautifulsoup4<5.0.0,>=4.12.1->scopesim) (2.5)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx<0.24.0,>=0.23.0->scopesim) (2024.7.4)\n", + "Requirement already satisfied: httpcore<0.17.0,>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from httpx<0.24.0,>=0.23.0->scopesim) (0.16.3)\n", + "Requirement already satisfied: rfc3986<2,>=1.3 in /usr/local/lib/python3.10/dist-packages (from rfc3986[idna2008]<2,>=1.3->httpx<0.24.0,>=0.23.0->scopesim) (1.5.0)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx<0.24.0,>=0.23.0->scopesim) (1.3.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.7.2->scopesim) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.7.2->scopesim) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.7.2->scopesim) (4.53.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.7.2->scopesim) (1.4.5)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.7.2->scopesim) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.7.2->scopesim) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.7.2->scopesim) (2.8.2)\n", + "Requirement already satisfied: platformdirs>=2.5.0 in /usr/local/lib/python3.10/dist-packages (from pooch<2.0.0,>=1.7.0->scopesim) (4.2.2)\n", + "Requirement already satisfied: requests>=2.19.0 in /usr/local/lib/python3.10/dist-packages (from pooch<2.0.0,>=1.7.0->scopesim) (2.31.0)\n", + "Requirement already satisfied: h11<0.15,>=0.13 in /usr/local/lib/python3.10/dist-packages (from httpcore<0.17.0,>=0.15.0->httpx<0.24.0,>=0.23.0->scopesim) (0.14.0)\n", + "Requirement already satisfied: anyio<5.0,>=3.0 in /usr/local/lib/python3.10/dist-packages (from httpcore<0.17.0,>=0.15.0->httpx<0.24.0,>=0.23.0->scopesim) (3.7.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.7.2->scopesim) (1.16.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->pooch<2.0.0,>=1.7.0->scopesim) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->pooch<2.0.0,>=1.7.0->scopesim) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->pooch<2.0.0,>=1.7.0->scopesim) (2.0.7)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio<5.0,>=3.0->httpcore<0.17.0,>=0.15.0->httpx<0.24.0,>=0.23.0->scopesim) (1.2.2)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from scopesim_templates.stellar import cluster\n", + "\n", + "\n", + "src = cluster(mass=1E3, distance=50000, core_radius=1)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Mczzz3KcUzL0", + "outputId": "0748f1e7-7361-4346-cc74-00e3cc967baa" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[32mimf - sample_imf: Setting maximum allowed mass to 1000\u001b[0m\n", + "\u001b[32mimf - sample_imf: Loop 0 added 1.09e+03 Msun to previous total of 0.00e+00 Msun\u001b[0m\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Downloading file 'filter_systems/etc/index.yml' from 'https://scopesim.univie.ac.at/spextra/database/filter_systems/etc/index.yml' to '/root/.spextra_cache'.\n", + "100%|██████████████████████████████████████████| 609/609 [00:00<00:00, 135kB/s]\n", + "Downloading file 'filter_systems/etc/V.dat' from 'https://scopesim.univie.ac.at/spextra/database/filter_systems/etc/V.dat' to '/root/.spextra_cache'.\n", + "100%|██████████████████████████████████████| 3.18k/3.18k [00:00<00:00, 804kB/s]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "src.fields\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hQvqPUhqVjUZ", + "outputId": "583b2ac8-7abe-40a5-bbeb-182ba3bede4e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[\n", + " x y ... masses spec_types\n", + " arcsec arcsec ... solMass \n", + " float64 float64 ... float64 str7 \n", + " ------------------- -------------------- ... -------------------- ----------\n", + " 0.7047941071430335 -0.34193400839906835 ... 0.023450818028910993 M6V\n", + " 3.017163801660643 -1.531947677274888 ... 0.5030213194041789 M1V\n", + " 5.545342770168751 -0.5059378004225308 ... 0.6887993545486397 K5V\n", + " 0.04337484405135695 0.47394950595035895 ... 0.16592467519086804 M5V\n", + " -0.1695198026107141 2.689008599028229 ... 0.4981528843145076 M1V\n", + " 2.903227971744357 -0.42880293404815345 ... 0.030385458123976427 M6V\n", + " 2.9147725521817955 1.4290979035892837 ... 0.12048133658240405 M5V\n", + " 2.1879322601012166 1.7393082707150282 ... 0.33768446357534043 M3V\n", + " -0.5711617098260228 -5.393018142881724 ... 0.8167460590486888 K2V\n", + " ... ... ... ... ...\n", + " 1.4678772515789662 -0.17251949373959752 ... 0.6961978840502374 K5V\n", + " -2.9862656254225963 0.5421006937620638 ... 0.12278256100621125 M5V\n", + " 3.157740384424968 3.0596228361838076 ... 1.1792543689064683 F8V\n", + " 2.358628131504372 -1.557299020469622 ... 0.012963210764621674 M6V\n", + " 1.4521739653435157 -0.851382522869428 ... 0.117485467623293 M6V\n", + " -0.4565704589836154 0.18085670454520986 ... 0.26443896759352503 M3V\n", + " -4.2880207051930626 4.243801810096584 ... 0.48208630286109483 M1V\n", + " -1.0717398664268987 3.7082294509014195 ... 0.08623356844839875 M6V\n", + " 2.1224836756915306 1.1488760649099696 ... 0.05865254767345462 M6V\n", + " -4.886571147953505 1.7463696161882218 ... 0.3244795598952535 M3V]" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(8, 8))\n", + "plt.plot(src.fields[0][\"x\"], src.fields[0][\"y\"], '.')\n", + "plt.xlabel(\"X [arcsec]\")\n", + "plt.ylabel(\"Y [arcsec]\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 714 + }, + "id": "EimFNanwVrDD", + "outputId": "75ba5c44-4072-4889-bb18-6f94171222c7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0, 0.5, 'Y [arcsec]')" + ] + }, + "metadata": {}, + "execution_count": 12 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "import astropy" + ], + "metadata": { + "id": "AMWfW90EdEPh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from astropy.table import QTable\n", + "import astropy.units as u\n", + "import numpy as np\n" + ], + "metadata": { + "id": "SoLqfFxudNWf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "pip install astropy astroquery matplotlib\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RpwXcCvXk91v", + "outputId": "c12107ad-736e-48e8-aee0-c1b8591e87a6" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: astropy in /usr/local/lib/python3.10/dist-packages (5.3.4)\n", + "Collecting astroquery\n", + " Downloading astroquery-0.4.7-py3-none-any.whl.metadata (7.2 kB)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (3.9.0)\n", + "Requirement already satisfied: numpy<2,>=1.21 in /usr/local/lib/python3.10/dist-packages (from astropy) (1.26.4)\n", + "Requirement already satisfied: pyerfa>=2.0 in /usr/local/lib/python3.10/dist-packages (from astropy) (2.0.1.4)\n", + "Requirement already satisfied: PyYAML>=3.13 in /usr/local/lib/python3.10/dist-packages (from astropy) (6.0.1)\n", + "Requirement already satisfied: packaging>=19.0 in /usr/local/lib/python3.10/dist-packages (from astropy) (24.1)\n", + "Requirement already satisfied: requests>=2.19 in /usr/local/lib/python3.10/dist-packages (from astroquery) (2.31.0)\n", + "Requirement already satisfied: beautifulsoup4>=4.8 in /usr/local/lib/python3.10/dist-packages (from astroquery) (4.12.3)\n", + "Requirement already satisfied: html5lib>=0.999 in /usr/local/lib/python3.10/dist-packages (from astroquery) (1.1)\n", + "Requirement already satisfied: keyring>=15.0 in /usr/lib/python3/dist-packages (from astroquery) (23.5.0)\n", + "Collecting pyvo>=1.1 (from astroquery)\n", + " Downloading pyvo-1.5.2-py3-none-any.whl.metadata (4.7 kB)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (4.53.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.4.5)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.10/dist-packages (from beautifulsoup4>=4.8->astroquery) (2.5)\n", + "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.10/dist-packages (from html5lib>=0.999->astroquery) (1.16.0)\n", + "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from html5lib>=0.999->astroquery) (0.5.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19->astroquery) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19->astroquery) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19->astroquery) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19->astroquery) (2024.7.4)\n", + "Downloading astroquery-0.4.7-py3-none-any.whl (5.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.3/5.3 MB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pyvo-1.5.2-py3-none-any.whl (910 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m910.8/910.8 kB\u001b[0m \u001b[31m9.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: pyvo, astroquery\n", + "Successfully installed astroquery-0.4.7 pyvo-1.5.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from astropy.table import Table\n", + "import matplotlib.pyplot as plt\n", + "from astroquery.simbad import Simbad\n", + "from astropy.coordinates import SkyCoord\n", + "import astropy.units as u\n" + ], + "metadata": { + "id": "-fUNm7w7lIXJ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from astropy.table import Table\n", + "import matplotlib.pyplot as plt\n", + "from astroquery.gaia import Gaia\n", + "import astropy.units as u\n", + "from astropy.coordinates import SkyCoord\n", + "\n", + "# Define the query for Gaia\n", + "query = \"\"\"\n", + "SELECT TOP 1000\n", + " source_id,\n", + " ra,\n", + " dec,\n", + " phot_g_mean_mag,\n", + " bp_rp\n", + "FROM gaiadr2.gaia_source\n", + "WHERE CONTAINS(\n", + " POINT('ICRS', ra, dec),\n", + " CIRCLE('ICRS', 75.0, -65.0, 5)\n", + ")=1\n", + "\"\"\"\n", + "\n", + "# Execute the query\n", + "job = Gaia.launch_job(query)\n", + "result = job.get_results()\n", + "\n", + "# Convert the results to an Astropy table\n", + "star_table = Table(result)\n", + "\n", + "# Display the table\n", + "print(star_table)\n", + "\n", + "# Plot the star field\n", + "plt.figure(figsize=(10, 10))\n", + "plt.scatter(star_table['ra'], star_table['dec'], s=10, c='white')\n", + "plt.gca().invert_yaxis() # Invert y-axis to match astronomical convention\n", + "plt.gca().set_facecolor('black') # Set the background color to black\n", + "plt.title('Star Field of Dorado Constellation')\n", + "plt.xlabel('RA (degrees)')\n", + "plt.ylabel('Dec (degrees)')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "uUnEhR9ClNDp", + "outputId": "31f08023-3207-48e6-dc82-14f08867fb28" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " SOURCE_ID ra ... phot_g_mean_mag bp_rp \n", + " deg ... mag mag \n", + "------------------- ----------------- ... --------------- ------------\n", + "4662919794243475840 72.7660842539151 ... 21.10991 --\n", + "4662919003978495488 72.82551465050375 ... 16.21827 1.8037281\n", + "4662923505095502080 73.24361411726106 ... 20.848244 -0.29154396\n", + "4662915018242323840 73.15924806671195 ... 20.814703 0.23135567\n", + "4662918007537116288 73.01395758290441 ... 20.276127 0.86989784\n", + "4662937386430040960 72.18974073577743 ... 18.685677 0.89114\n", + "4662925253162516224 73.02975371282093 ... 18.94579 1.2791443\n", + "4662874847410814976 68.77607885434055 ... 16.293564 0.9358797\n", + "4662924222356262528 73.23873690368688 ... 17.773794 -0.1875019\n", + "4662930338390336768 72.94207524304505 ... 20.27316 0.47165298\n", + " ... ... ... ... ...\n", + "4662941956284055168 72.52602339970234 ... 19.662247 0.27460098\n", + "4662923779974132608 73.16113089160135 ... 20.56335 0.4067192\n", + "4662922027635655552 72.8926365632069 ... 19.772848 0.2648239\n", + "4662942402952360960 72.48492768762556 ... 18.885538 1.049612\n", + "4662914502852743808 73.11497486280486 ... 20.085327 -0.017742157\n", + "4662929037015853824 72.73728251686379 ... 21.115808 --\n", + "4662906222147998976 69.20045755557811 ... 19.598658 --\n", + "4662917182905118976 73.0811393979387 ... 20.7303 0.40285492\n", + "4662918179344862592 72.96356054194248 ... 19.981756 0.073246\n", + "4662841484104750720 69.87093736591488 ... 20.877447 0.87417984\n", + "Length = 1000 rows\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from astropy.table import Table\n", + "import matplotlib.pyplot as plt\n", + "from astroquery.gaia import Gaia\n", + "import astropy.units as u\n", + "from astropy.coordinates import SkyCoord\n", + "\n", + "# Define the query for Gaia\n", + "query = \"\"\"\n", + "SELECT TOP 1000\n", + " source_id,\n", + " ra,\n", + " dec,\n", + " phot_g_mean_mag,\n", + " bp_rp\n", + "FROM gaiadr2.gaia_source\n", + "WHERE CONTAINS(\n", + " POINT('ICRS', ra, dec),\n", + " CIRCLE('ICRS', 90.0, -75.0, 5)\n", + ")=1\n", + "\"\"\"\n", + "\n", + "# Execute the query\n", + "job = Gaia.launch_job(query)\n", + "result = job.get_results()\n", + "\n", + "# Convert the results to an Astropy table\n", + "star_table = Table(result)\n", + "\n", + "# Display the table\n", + "print(star_table)\n", + "\n", + "# Plot the star field\n", + "plt.figure(figsize=(10, 10))\n", + "plt.scatter(star_table['ra'], star_table['dec'], s=10, c='white')\n", + "plt.gca().invert_yaxis() # Invert y-axis to match astronomical convention\n", + "plt.gca().set_facecolor('black') # Set the background color to black\n", + "plt.title('Star Field of Mensa Constellation')\n", + "plt.xlabel('RA (degrees)')\n", + "plt.ylabel('Dec (degrees)')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "teaFHYJDmH8O", + "outputId": "48a550f6-69fe-4ba5-92f3-81364ef49be0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " SOURCE_ID ra ... phot_g_mean_mag bp_rp \n", + " deg ... mag mag \n", + "------------------- ----------------- ... --------------- -----------\n", + "4650814927136960000 85.85262033910165 ... 20.839825 0.73988724\n", + "4650808085281396608 86.39271577504434 ... 20.62958 0.49964714\n", + "4650808394493643008 86.49425140095568 ... 20.585037 0.30471802\n", + "4650809871987381248 86.65624210169915 ... 20.470694 --\n", + "4650805272060164608 87.11597358981999 ... 19.857107 1.1211338\n", + "4650806577730105216 86.88168555052404 ... 18.912148 0.33413315\n", + "4650810013700362368 86.51761427553822 ... 20.93511 0.7413807\n", + "4650810249919557632 86.4551981957551 ... 19.72775 0.12936592\n", + "4650804756660599424 87.11455398622944 ... 20.894976 0.027791977\n", + "4650811388085230464 85.9027602275617 ... 20.83379 0.7212105\n", + " ... ... ... ... ...\n", + "4650814063847213440 85.99411322749931 ... 19.473928 0.824728\n", + "4650811211999103744 86.05100513744152 ... 18.745077 1.1922779\n", + "4650813307932913792 86.03532637051946 ... 19.063814 1.199173\n", + "4650821318049429376 85.7117272002812 ... 20.923588 1.0083065\n", + "4650817744635035264 85.58089699125316 ... 20.13649 0.6758671\n", + "4650806886963681792 86.70888882008953 ... 20.72311 0.5260372\n", + "4650802415919396736 87.23960985565544 ... 20.661968 0.5091858\n", + "4650817160519216768 85.3036841820232 ... 19.507359 0.5188885\n", + "4650809837602302464 86.71935700292266 ... 18.667803 1.2366505\n", + "4650820493414018688 86.02989258830004 ... 20.192488 0.17674828\n", + "Length = 1000 rows\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "from scopesim_templates.stellar import star_field, star_grid\n", + "\n", + "field = star_field(n=400, mmin=15, mmax=25, width=20, height=20, filter_name=\"Ks\")\n", + "grid = star_grid(n=400, mmin=15, mmax=25, separation=1 , filter_name=\"Ks\")\n", + "\n", + "plt.figure(figsize=(14, 7))\n", + "plt.subplot(121)\n", + "\n", + "size = np.log10(field.fields[0][\"weight\"])**2\n", + "plt.scatter(field.fields[0][\"x\"], field.fields[0][\"y\"], s=size, marker=\"o\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 617 + }, + "id": "Mtz9oAyYmu5o", + "outputId": "7a86eefd-bd6f-4fd9-f5b2-49c36208e2c3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 30 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "tsRbG1pAnTch" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 28af36522f1a3cd980fbe0d11e0ebeff6bef436c Mon Sep 17 00:00:00 2001 From: Astrogirlanjali Date: Thu, 8 Aug 2024 18:02:08 +1000 Subject: [PATCH 06/43] changed default file --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes DREAMS/Test_codes/.DS_Store | Bin 6148 -> 6148 bytes DREAMS/Test_codes/testt.py | 2 +- DREAMS/default.yaml | 6 +++--- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index 062e9c3ef5121fa2021b655240078459e868019e..de18533f18a8fb820e1991bd1ef35b6c018bb9ef 100644 GIT binary patch delta 189 zcmZp1XmOa}¥U^hRb!ekx+M`ku>zR3Xs5-fg>n~qM-5s-l}dIV&dI3G-2El{-i zsvr~ND7#N5!TMNzbREB(@H4zNy3{hx?U){_n zD9FfeY^D>3&hkAOsUC_goG!%ii%FY VCsw$bUE&+dW>=Aaj3nvH0{~fyQxX6G diff --git a/DREAMS/Test_codes/.DS_Store b/DREAMS/Test_codes/.DS_Store index d412ff8dce0ac345bc1736a5d02d62f4ec5b9c30..909612eb40b1ac327d4049fa5b1cab5e859befe5 100644 GIT binary patch delta 25 hcmZoMXffEJ&CK4(z`$Vq|NmwK=Bq55**X650|09R2$cW; delta 32 kcmZoMXffEJ&CK1+z`&sQ9}G4-G9P1^*ucG+o#QV*0NLpcumAu6 diff --git a/DREAMS/Test_codes/testt.py b/DREAMS/Test_codes/testt.py index 4acce217..9bf0bcf3 100644 --- a/DREAMS/Test_codes/testt.py +++ b/DREAMS/Test_codes/testt.py @@ -17,7 +17,7 @@ pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") # Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/Desktop" +TOP_PATH = "/Users/anjali/github" rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH # Adjust the PKGS dictionary to reflect the correct path diff --git a/DREAMS/default.yaml b/DREAMS/default.yaml index 56bb6574..9f3c6dbd 100644 --- a/DREAMS/default.yaml +++ b/DREAMS/default.yaml @@ -19,15 +19,15 @@ properties : pupil_angle : 0 dit : 10 ndit : 1 - filter_name : !OBS.filter_name + filter_name : J sky : bg_mag : 14.5 - filter_name : !OBS.filter_name + filter_name : J --- ### default simulation parameters needed for DREAMS simulation object : simulation -alias : SIM +alias : OBS name : LFAO_simulation_paramters description : RC simulation paramters From f9ec3c6bb75b6bdd5760bdab9ed753ecbde229e6 Mon Sep 17 00:00:00 2001 From: Astrogirlanjali Date: Fri, 9 Aug 2024 10:34:30 +1000 Subject: [PATCH 07/43] changes --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes DREAMS/DREAMS.yaml | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index de18533f18a8fb820e1991bd1ef35b6c018bb9ef..4142f4c3258bee80b4aeacd5d43fce01f729cbac 100644 GIT binary patch delta 44 ycmZp1XmQx!C%_c`2j#z4wC=? diff --git a/DREAMS/DREAMS.yaml b/DREAMS/DREAMS.yaml index 0bf83cca..1c65ad30 100644 --- a/DREAMS/DREAMS.yaml +++ b/DREAMS/DREAMS.yaml @@ -28,7 +28,7 @@ effects: rescale_emission: filter_name: "!OBS.filter_name" filename_format: "filters/{}.dat" - value: "!OBS.bg_mag" + value: "!OBS.sky.bg_mag" unit: mag - name: dreams_static_surfaces description : telescope and camera optical surfaces From b41124d216822111552f8ddc3dcc38cd62993aef Mon Sep 17 00:00:00 2001 From: Astrogirlanjali Date: Sun, 11 Aug 2024 18:10:43 +1000 Subject: [PATCH 08/43] All changes added --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes DREAMS/DREAMS.yaml | 4 ++-- DREAMS/default.yaml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index 4142f4c3258bee80b4aeacd5d43fce01f729cbac..a66d927ed8fa56f0341dac4141145832b2db3ca4 100644 GIT binary patch delta 54 zcmZp1XmQx!C%}}cJ2^l=k|l82?X#0}1*BPnz^q;YS;hsMR|^y~a+n$!=qQ*NTW(ep Hy2lFu3)&Je delta 49 zcmZp1XmQx!C%_c Date: Sun, 11 Aug 2024 18:14:03 +1000 Subject: [PATCH 09/43] added changes --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index a66d927ed8fa56f0341dac4141145832b2db3ca4..2e8d32c8d9a70e6e4c7724f5eb32308d5e4c8710 100644 GIT binary patch delta 43 scmZp1XmQx!C%{xvF*!g$f=#4w+rbc%$$0`&FlL{C4C9B*s|6zY0YcFZ;{X5v delta 43 tcmZp1XmQx!C%}}cJ2^l=f-NX;+3mANlk)_mV9Y)N8O8;hR|`b)0{~5(4|@Or From 41cb582972cf303053aff76a01d5cda46da46b02 Mon Sep 17 00:00:00 2001 From: Astrogirlanjali Date: Thu, 29 Aug 2024 12:39:16 +1000 Subject: [PATCH 10/43] Added S0, elliptical galaxy --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes DREAMS/DREAMS.yaml | 2 +- DREAMS/Test_codes/.DS_Store | Bin 6148 -> 6148 bytes DREAMS/Test_codes/Galaxy.py | 88 +++++++++++++++++++++++++ DREAMS/Test_codes/LMC.py | 4 +- DREAMS/Test_codes/{gal.py => ellip.py} | 39 +++++------ 6 files changed, 106 insertions(+), 27 deletions(-) create mode 100644 DREAMS/Test_codes/Galaxy.py rename DREAMS/Test_codes/{gal.py => ellip.py} (79%) diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index 2e8d32c8d9a70e6e4c7724f5eb32308d5e4c8710..21b989c1f866dcf662616f139e58502658bcd2bd 100644 GIT binary patch delta 170 zcmZp1XmQx!C%{xaVRC?g1gqq~<*K2Ra|NWKtX=^bCT@kzs|EB~*-ecMbQBCNCaVfL zOjZhmA7*YK#CD Ck~25} delta 172 zcmZp1XmQx!C%{xvF*!g$f>oq&+rf~@xdPHqR Date: Thu, 29 Aug 2024 12:44:21 +1000 Subject: [PATCH 11/43] Resolved merge conflicts --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index 21b989c1f866dcf662616f139e58502658bcd2bd..728f1a9e2aee569aad8fa285f7f8494af1c7c26f 100644 GIT binary patch delta 43 tcmZp1XmQx!C%`m+ Date: Sat, 14 Sep 2024 01:23:50 +1000 Subject: [PATCH 12/43] Added block filter --- DREAMS/.DS_Store | Bin 8196 -> 8196 bytes DREAMS/filters/.DS_Store | Bin 6148 -> 6148 bytes DREAMS/filters/H_block.dat | 8 ++++++++ DREAMS/filters/J_block.dat | 8 ++++++++ 4 files changed, 16 insertions(+) create mode 100644 DREAMS/filters/H_block.dat create mode 100644 DREAMS/filters/J_block.dat diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store index 728f1a9e2aee569aad8fa285f7f8494af1c7c26f..7b606e48ef8f39510ecbc28771ce7d1275f4630a 100644 GIT binary patch delta 52 zcmZp1XmQx!E5OXon>#r`K!UYd?gA6faW@I)sGT5vr^q3a_ D+Hesr diff --git a/DREAMS/filters/.DS_Store b/DREAMS/filters/.DS_Store index f1c73ea079c988ca8326d6ada74fe1ededa92a33..1e595d4cbdbf69232cf5bacab60ffa054592ff66 100644 GIT binary patch delta 135 zcmZoMXfc@J&&WD4U^gS{WFAIcV{QfyhIob~h8%``hGd3p20exphD3%E&z$_^q@4UD q1_lNJAifC1YyLyQWHZKapgu1m^w|UTt%K>?Jdsh5Z8JN^Uw!}>H!6Mr delta 34 qcmZoMXfc@J&&WJ6U^gT4WFAJ{$@z>Sn}0L%uuW{p+sw}KmmdJUR|_5h diff --git a/DREAMS/filters/H_block.dat b/DREAMS/filters/H_block.dat new file mode 100644 index 00000000..c1def74f --- /dev/null +++ b/DREAMS/filters/H_block.dat @@ -0,0 +1,8 @@ +# source : Generic_Bessell.I SVO +# wavelength_unit : angstrom +# download_date : 2020-05-23 +wavelength transmission +14900.0 0.0 +16700.0 0.0 + + diff --git a/DREAMS/filters/J_block.dat b/DREAMS/filters/J_block.dat new file mode 100644 index 00000000..a3664a86 --- /dev/null +++ b/DREAMS/filters/J_block.dat @@ -0,0 +1,8 @@ +# source : Generic_Bessell.I SVO +# wavelength_unit : angstrom +# download_date : 2020-05-23 +wavelength transmission +11610.0 0.0 +13330.0 0.870898 + + From 0f290ffa23bbb7bd3c3bc9ec3c09cc2ffb6e3599 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Sun, 11 Aug 2024 18:04:53 +1000 Subject: [PATCH 13/43] Create README.md --- DREAMS/README.md | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 DREAMS/README.md diff --git a/DREAMS/README.md b/DREAMS/README.md new file mode 100644 index 00000000..362de378 --- /dev/null +++ b/DREAMS/README.md @@ -0,0 +1,6 @@ + +# DREAMS Teelescope + +The Dynamic REd All-sky Monitoring Survey (DREAMS) is a cutting-edge 0.5-meter infrared telescope, strategically situated at the Siding Spring Observatory, part of the Australian National University. DREAMS is pioneering in its application of Indium Gallium Arsenide (InGaAs) detectors, which, despite having a higher noise profile, offer a cost-effective alternative to the traditionally used mercury-cadmium-telluride (HgCdTe) detectors in infrared astronomy. The telescope is equipped with the advanced Princeton Infrared Technologies 1280SCICAM, enabling high-sensitivity observations across the near-infrared spectrum. + +DREAMS is designed to push the boundaries of wide-field time-domain astronomy, in parallel with other state-of-the-art surveys such as Palomar Gattini-IR and WINTER. As a southern sky near-infrared time-domain survey, DREAMS is uniquely positioned to make significant contributions to a range of astrophysical phenomena. These include the detection and characterization of Fast Radio Bursts (FRBs), the study of variable stars such as RR Lyrae, and the advancement of multi-messenger astronomy by providing crucial infrared observations that complement data from other wavelengths and messengers. From 80994e151e5dcf282135571161f94b056bcde0a4 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Sun, 11 Aug 2024 18:05:22 +1000 Subject: [PATCH 14/43] Update README.md --- DREAMS/README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/DREAMS/README.md b/DREAMS/README.md index 362de378..d98d865a 100644 --- a/DREAMS/README.md +++ b/DREAMS/README.md @@ -1,4 +1,3 @@ - # DREAMS Teelescope The Dynamic REd All-sky Monitoring Survey (DREAMS) is a cutting-edge 0.5-meter infrared telescope, strategically situated at the Siding Spring Observatory, part of the Australian National University. DREAMS is pioneering in its application of Indium Gallium Arsenide (InGaAs) detectors, which, despite having a higher noise profile, offer a cost-effective alternative to the traditionally used mercury-cadmium-telluride (HgCdTe) detectors in infrared astronomy. The telescope is equipped with the advanced Princeton Infrared Technologies 1280SCICAM, enabling high-sensitivity observations across the near-infrared spectrum. From f9e274ff4bfeac054ecc6878fd0b8862f5942a20 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Sun, 11 Aug 2024 18:17:22 +1000 Subject: [PATCH 15/43] Update DREAMS.yaml --- DREAMS/DREAMS.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/DREAMS/DREAMS.yaml b/DREAMS/DREAMS.yaml index 2107ae05..f575f82f 100644 --- a/DREAMS/DREAMS.yaml +++ b/DREAMS/DREAMS.yaml @@ -18,7 +18,7 @@ effects: description : Schoepfl PSF class : SeeingPSF kwargs : - fwhm : 15.00 # [arcsec] + fwhm : 5.00 # [arcsec] - name : skycalc_average_atmo description : atmospheric properties for a default skycalc run class : AtmosphericTERCurve From 0dc4993a7f1164ff2f41ab2389fbdb1672f3a712 Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 21:51:54 +0200 Subject: [PATCH 16/43] Delete .DS_Store --- DREAMS/.DS_Store | Bin 8196 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 DREAMS/.DS_Store diff --git a/DREAMS/.DS_Store b/DREAMS/.DS_Store deleted file mode 100644 index 7b606e48ef8f39510ecbc28771ce7d1275f4630a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8196 zcmeHMO=}ZD7=9;>$@bGwD%68zK@bn6CR)YfB~4SM#ez0P4=QWY#CCDB6Y^n@QVe+0 z|KMNn>e+)w5d^(@^Wx2uCw=Cl>F#Eu2SKIIl$m#T-jA7m=6QE^QX*o7PBlj~OGFl` zkeP8bF-7P_9ViLiV?#3d)0)S(D;}@lKBIL;7z7Lg1_6VBLBJsJZy|s^TNG=^zOS^V zH3%34{!0YJ`@u#PGOuM%N%`tPBaZ-(Np#DCYx(I9X^RfXyp}yB(SyR2E2MH|`iQ~w z$$=?%==0jXr=)TxCPzjbJu=fL6s8Xz%$DZF@=BW4AYc#}M8HN@k``!(Txy5U?};7g z7QV|O9s73PPOh}g>kZkPo~#FB)OoR}e*>_d&b>=apjq*i#I?D@~FE8SK@BlxP)@Z45AoBhBNBgtc_w3W8Tt$U?i-YvDu z?M|yuZr%}hTbz59gX?nTmRsvOnVA*tx67_yYf1;VT7${m+pb^b-2(6U)t2-vDTOs^ zjXIgxy}iX;Zr)zJu(UsK?=79rit9`J`=i#0)90>iIuE_N&!6E5P?&xh)1VpCImw(zoH{?`&v2^{i%1eR66aB=>3iH492ZY9Ls#hr*4V*H zH}O{n#~iGnkQ}@dtgGTKk|XRJe1n{uqw8QyiMHS!WS;}Rx-v2sjDWUmoIZr`h>g%-!A)da zG-F~=llc;y@ig#SMXn0;+n6B-It|)I);Ce(kr#Ozj4{=Z5kxxPSMW3FI|kpHToDJW z!R7lVlC`uBq8tybMy$`@&fSY5Uvrm#H+N&7EySkO)@xuGYZqkJM(WGgF|`8>u{~tj zuWUn%OZ6~({P>Z~7Ivn@AuyskXT|w{b@=c9ajvG%AYc$UA_%Z#u~aPJVGcg$qR*8; zhmCq4RTN>@Q&PI15hkKv9>*d3|1iY0t#x@VdrCrs^2dJ&z*ms`0yq1=#6R}iJ$A1) L`@aJ0XtX~7nMF0J From 0466336a5f2f9bc07220878b188b580455aa57de Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Sun, 11 Aug 2024 18:18:53 +1000 Subject: [PATCH 17/43] Update README.md --- DREAMS/README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/DREAMS/README.md b/DREAMS/README.md index d98d865a..f3c705bb 100644 --- a/DREAMS/README.md +++ b/DREAMS/README.md @@ -1,4 +1,5 @@ -# DREAMS Teelescope +# DREAMS Telescope in a nutshell: +--------------------------------------------------------------- The Dynamic REd All-sky Monitoring Survey (DREAMS) is a cutting-edge 0.5-meter infrared telescope, strategically situated at the Siding Spring Observatory, part of the Australian National University. DREAMS is pioneering in its application of Indium Gallium Arsenide (InGaAs) detectors, which, despite having a higher noise profile, offer a cost-effective alternative to the traditionally used mercury-cadmium-telluride (HgCdTe) detectors in infrared astronomy. The telescope is equipped with the advanced Princeton Infrared Technologies 1280SCICAM, enabling high-sensitivity observations across the near-infrared spectrum. From 51622eb85463d95e532de43d437ef4bab0357ad1 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Sun, 11 Aug 2024 18:28:35 +1000 Subject: [PATCH 18/43] Update README.md --- DREAMS/README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/DREAMS/README.md b/DREAMS/README.md index f3c705bb..cbd8cb12 100644 --- a/DREAMS/README.md +++ b/DREAMS/README.md @@ -1,5 +1,4 @@ # DREAMS Telescope in a nutshell: ---------------------------------------------------------------- The Dynamic REd All-sky Monitoring Survey (DREAMS) is a cutting-edge 0.5-meter infrared telescope, strategically situated at the Siding Spring Observatory, part of the Australian National University. DREAMS is pioneering in its application of Indium Gallium Arsenide (InGaAs) detectors, which, despite having a higher noise profile, offer a cost-effective alternative to the traditionally used mercury-cadmium-telluride (HgCdTe) detectors in infrared astronomy. The telescope is equipped with the advanced Princeton Infrared Technologies 1280SCICAM, enabling high-sensitivity observations across the near-infrared spectrum. From 6cf5604d439658d2974583d6d8bc9f357dde4444 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Sun, 11 Aug 2024 18:29:12 +1000 Subject: [PATCH 19/43] Update README.md --- DREAMS/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/DREAMS/README.md b/DREAMS/README.md index cbd8cb12..dc1da135 100644 --- a/DREAMS/README.md +++ b/DREAMS/README.md @@ -1,5 +1,5 @@ # DREAMS Telescope in a nutshell: -The Dynamic REd All-sky Monitoring Survey (DREAMS) is a cutting-edge 0.5-meter infrared telescope, strategically situated at the Siding Spring Observatory, part of the Australian National University. DREAMS is pioneering in its application of Indium Gallium Arsenide (InGaAs) detectors, which, despite having a higher noise profile, offer a cost-effective alternative to the traditionally used mercury-cadmium-telluride (HgCdTe) detectors in infrared astronomy. The telescope is equipped with the advanced Princeton Infrared Technologies 1280SCICAM, enabling high-sensitivity observations across the near-infrared spectrum. +The Dynamic REd All-Sky Monitoring Survey (DREAMS) is a cutting-edge 0.5-meter infrared telescope strategically situated at the Siding Spring Observatory, part of the Australian National University. DREAMS is pioneering in its application of Indium Gallium Arsenide (InGaAs) detectors, which, despite having a higher noise profile, offer a cost-effective alternative to the traditionally used mercury-cadmium-telluride (HgCdTe) detectors in infrared astronomy. The telescope is equipped with the advanced Princeton Infrared Technologies 1280SCICAM, enabling high-sensitivity observations across the near-infrared spectrum. -DREAMS is designed to push the boundaries of wide-field time-domain astronomy, in parallel with other state-of-the-art surveys such as Palomar Gattini-IR and WINTER. As a southern sky near-infrared time-domain survey, DREAMS is uniquely positioned to make significant contributions to a range of astrophysical phenomena. These include the detection and characterization of Fast Radio Bursts (FRBs), the study of variable stars such as RR Lyrae, and the advancement of multi-messenger astronomy by providing crucial infrared observations that complement data from other wavelengths and messengers. +DREAMS is designed to push the boundaries of wide-field time-domain astronomy in parallel with other surveys such as Palomar Gattini-IR and WINTER. As a southern sky near-infrared time-domain survey, DREAMS is uniquely positioned to contribute to a range of astrophysical phenomena significantly. These include detecting and characterising Fast Radio Bursts (FRBs), studying variable stars such as RR Lyrae, and advancing multi-messenger astronomy by providing crucial infrared observations that complement data from other wavelengths and messengers. From 22adb9d97ed4d84c6774c0f97fa234bd7ce972c3 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Tue, 13 Aug 2024 11:06:51 +1000 Subject: [PATCH 20/43] Update DREAMS_InGaAs.yaml --- DREAMS/DREAMS_InGaAs.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/DREAMS/DREAMS_InGaAs.yaml b/DREAMS/DREAMS_InGaAs.yaml index 1b9c6e12..e59666ca 100644 --- a/DREAMS/DREAMS_InGaAs.yaml +++ b/DREAMS/DREAMS_InGaAs.yaml @@ -3,7 +3,7 @@ object : detector alias : DET name : DREAMS_InGaAs_detector -description : base configuration for LFOA SBIG camera +description : base configuration for Dreams camera properties: image_plane_id : 0 @@ -59,4 +59,4 @@ effects: description : Binning the detector frames class : BinnedImage kwargs : - bin_size : "!DET.bin_size" \ No newline at end of file + bin_size : "!DET.bin_size" From fe1a5383e183b056d4717434b89750d0393537a9 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Wed, 14 Aug 2024 23:25:02 +1000 Subject: [PATCH 21/43] Add files via upload --- DREAMS/Test_codes/Lc.py | 75 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 DREAMS/Test_codes/Lc.py diff --git a/DREAMS/Test_codes/Lc.py b/DREAMS/Test_codes/Lc.py new file mode 100644 index 00000000..132f5bbf --- /dev/null +++ b/DREAMS/Test_codes/Lc.py @@ -0,0 +1,75 @@ +#cluster in the LMC +import os +import pytest +import numpy as np +from astropy.io.fits import HDUList +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +import scopesim +import synphot +from scopesim import Source +from astropy.io import fits + + +from scopesim import rc +from scopesim.source.source_templates import star_field +import scopesim_templates as sim_tp +from scopesim_templates.stellar import cluster + +from scopesim.optics.fov_manager import FOVManager + +PLOTS = True + +if rc.__config__["!SIM.tests.run_integration_tests"] is False: + pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") + +# Set TOP_PATH to the directory containing the DREAMS package +TOP_PATH = "/Users/anjali/github" +rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH + +# Adjust the PKGS dictionary to reflect the correct path +PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} + +# Verify the path to the DREAMS package +if not os.path.exists(PKGS["DREAMS"]): + raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") +else: + print("DREAMS package found at:", PKGS["DREAMS"]) + +cmds = scopesim.UserCommands(use_instrument="DREAMS") +cmds["!OBS.dit"] = 1000 +cmds["!OBS.ndit"] = 1000 +cmds["!DET.bin_size"] = 1 +cmds["!OBS.sky.bg_mag"] = 14.9 +cmds["!OBS.sky.filter_name"] = "J" +cmds["SIM.sub_pixel.flag"] = True +dreams = scopesim.OpticalTrain(cmds) +dreams["detector_linearity"].include = False +dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) +# Then make the initial field of view 10 times larges than normal. +dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec +dreams.fov_manager.volumes_list[0]["x_max"] = 18000 +dreams.fov_manager.volumes_list[0]["y_min"] = -18000 +dreams.fov_manager.volumes_list[0]["y_max"] = 18000 +# Finally, shrink the field of view to the detector size. +dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) + +print("scopesim package loaded successfully.") +src = cluster(mass=1000, distance=50000, core_radius=500, seed=9002) + +dreams.observe(src, update=False) +print("yessss anjali") +hdus = dreams.readout() +dreams.readout(filename="Lc.fits") +#plt.subplot(121) +#wave = np.arange(3000, 11000) +#plt.plot(wave, dreams.optics_manager.surfaces_table.throughput(wave)) +plt.subplot(122) +im = hdus[0][1].data +plt.imshow(im, norm=LogNorm()) +plt.colorbar() +plt.title("Observed Star Field") +plt.xlabel("X Pixels") +plt.ylabel("Y Pixels") +plt.grid() +plt.show() From 73ea83da85bf9923b90883a2f6456dafd60efc94 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Wed, 14 Aug 2024 23:25:24 +1000 Subject: [PATCH 22/43] Add files via upload From f5ccaec12fe045db3e42e7c0bb76e34426ebe774 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Thu, 29 Aug 2024 12:41:30 +1000 Subject: [PATCH 23/43] Create SECURITY.md --- DREAMS/SECURITY.md | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 DREAMS/SECURITY.md diff --git a/DREAMS/SECURITY.md b/DREAMS/SECURITY.md new file mode 100644 index 00000000..034e8480 --- /dev/null +++ b/DREAMS/SECURITY.md @@ -0,0 +1,21 @@ +# Security Policy + +## Supported Versions + +Use this section to tell people about which versions of your project are +currently being supported with security updates. + +| Version | Supported | +| ------- | ------------------ | +| 5.1.x | :white_check_mark: | +| 5.0.x | :x: | +| 4.0.x | :white_check_mark: | +| < 4.0 | :x: | + +## Reporting a Vulnerability + +Use this section to tell people how to report a vulnerability. + +Tell them where to go, how often they can expect to get an update on a +reported vulnerability, what to expect if the vulnerability is accepted or +declined, etc. From fb8e97833e348071e25c5fc9f354a14bd8aa8d14 Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 21:52:55 +0200 Subject: [PATCH 24/43] Delete Test_codes/gal.py --- DREAMS/Test_codes/ellip.py | 76 -------------------------------------- 1 file changed, 76 deletions(-) delete mode 100644 DREAMS/Test_codes/ellip.py diff --git a/DREAMS/Test_codes/ellip.py b/DREAMS/Test_codes/ellip.py deleted file mode 100644 index ef452f57..00000000 --- a/DREAMS/Test_codes/ellip.py +++ /dev/null @@ -1,76 +0,0 @@ -#Elliptical Galaxy -import os -import pytest -import numpy as np -from astropy.io.fits import HDUList -from matplotlib import pyplot as plt -from matplotlib.colors import LogNorm -import scopesim -import synphot -from scopesim_templates.extragalactic.galaxies import elliptical -from astropy.io import fits - - -from scopesim import rc -from scopesim.source.source_templates import star_field -import scopesim_templates as sim_tp -from scopesim.optics.fov_manager import FOVManager - -PLOTS = True - -if rc.__config__["!SIM.tests.run_integration_tests"] is False: - pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") - -# Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/Desktop" -rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH - -# Adjust the PKGS dictionary to reflect the correct path -PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} - -# Verify the path to the DREAMS package -if not os.path.exists(PKGS["DREAMS"]): - raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") -else: - print("DREAMS package found at:", PKGS["DREAMS"]) - -cmds = scopesim.UserCommands(use_instrument="DREAMS") -cmds["!OBS.dit"] = 1000 -cmds["!OBS.ndit"] = 1000 -cmds["!DET.bin_size"] = 1 -cmds["!OBS.sky.bg_mag"] = 14.9 -cmds["!OBS.sky.filter_name"] = "J" -cmds["SIM.sub_pixel.flag"] = True -dreams = scopesim.OpticalTrain(cmds) -dreams["detector_linearity"].include = False -dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) -# Then make the initial field of view 10 times larges than normal. -dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec -dreams.fov_manager.volumes_list[0]["x_max"] = 18000 -dreams.fov_manager.volumes_list[0]["y_min"] = -18000 -dreams.fov_manager.volumes_list[0]["y_max"] = 18000 -# Finally, shrink the field of view to the detector size. -dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) - -print("scopesim package loaded successfully.") -src = elliptical(half_light_radius=11500, pixel_scale=2.48, filter_name="J", amplitude=17, normalization="total", n=4, ellipticity=0.5, angle=30) -dreams.observe(src, update=False) -hdus = dreams.readout() -dreams.readout(filename="ellip.fits") -plt.subplot(122) -im = hdus[0][1].data -plt.imshow(im, norm=LogNorm()) -plt.colorbar() -plt.title("Observed Galaxy Field") -plt.xlabel("X Pixels") -plt.ylabel("Y Pixels") - -detector_order = [2, 1, 4, 3, 6, 5] -plt.figure(figsize=(20, 20)) -for plot_number, hdu_number in enumerate(detector_order, 1): - plt.subplot(3, 2, plot_number) - plt.imshow(np.log10(src.fields[0].data), origin="lower") - plt.colorbar() - plt.title(f"HDU {hdu_number}") - -plt.show() From 4babf1de7bb4d67f780c8360f64495158d7ba203 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Thu, 29 Aug 2024 12:49:04 +1000 Subject: [PATCH 25/43] Add files via upload --- DREAMS/Test_codes/ellip.py | 76 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 DREAMS/Test_codes/ellip.py diff --git a/DREAMS/Test_codes/ellip.py b/DREAMS/Test_codes/ellip.py new file mode 100644 index 00000000..ef452f57 --- /dev/null +++ b/DREAMS/Test_codes/ellip.py @@ -0,0 +1,76 @@ +#Elliptical Galaxy +import os +import pytest +import numpy as np +from astropy.io.fits import HDUList +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +import scopesim +import synphot +from scopesim_templates.extragalactic.galaxies import elliptical +from astropy.io import fits + + +from scopesim import rc +from scopesim.source.source_templates import star_field +import scopesim_templates as sim_tp +from scopesim.optics.fov_manager import FOVManager + +PLOTS = True + +if rc.__config__["!SIM.tests.run_integration_tests"] is False: + pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") + +# Set TOP_PATH to the directory containing the DREAMS package +TOP_PATH = "/Users/anjali/Desktop" +rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH + +# Adjust the PKGS dictionary to reflect the correct path +PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} + +# Verify the path to the DREAMS package +if not os.path.exists(PKGS["DREAMS"]): + raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") +else: + print("DREAMS package found at:", PKGS["DREAMS"]) + +cmds = scopesim.UserCommands(use_instrument="DREAMS") +cmds["!OBS.dit"] = 1000 +cmds["!OBS.ndit"] = 1000 +cmds["!DET.bin_size"] = 1 +cmds["!OBS.sky.bg_mag"] = 14.9 +cmds["!OBS.sky.filter_name"] = "J" +cmds["SIM.sub_pixel.flag"] = True +dreams = scopesim.OpticalTrain(cmds) +dreams["detector_linearity"].include = False +dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) +# Then make the initial field of view 10 times larges than normal. +dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec +dreams.fov_manager.volumes_list[0]["x_max"] = 18000 +dreams.fov_manager.volumes_list[0]["y_min"] = -18000 +dreams.fov_manager.volumes_list[0]["y_max"] = 18000 +# Finally, shrink the field of view to the detector size. +dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) + +print("scopesim package loaded successfully.") +src = elliptical(half_light_radius=11500, pixel_scale=2.48, filter_name="J", amplitude=17, normalization="total", n=4, ellipticity=0.5, angle=30) +dreams.observe(src, update=False) +hdus = dreams.readout() +dreams.readout(filename="ellip.fits") +plt.subplot(122) +im = hdus[0][1].data +plt.imshow(im, norm=LogNorm()) +plt.colorbar() +plt.title("Observed Galaxy Field") +plt.xlabel("X Pixels") +plt.ylabel("Y Pixels") + +detector_order = [2, 1, 4, 3, 6, 5] +plt.figure(figsize=(20, 20)) +for plot_number, hdu_number in enumerate(detector_order, 1): + plt.subplot(3, 2, plot_number) + plt.imshow(np.log10(src.fields[0].data), origin="lower") + plt.colorbar() + plt.title(f"HDU {hdu_number}") + +plt.show() From 1ff59e676b2785aaf972a7deae7edf451b91e59d Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Tue, 1 Oct 2024 00:08:46 +1000 Subject: [PATCH 26/43] Create seeing_psf.py --- DREAMS/Test_codes/seeing_psf.py | 123 ++++++++++++++++++++++++++++++++ 1 file changed, 123 insertions(+) create mode 100644 DREAMS/Test_codes/seeing_psf.py diff --git a/DREAMS/Test_codes/seeing_psf.py b/DREAMS/Test_codes/seeing_psf.py new file mode 100644 index 00000000..03a56c0c --- /dev/null +++ b/DREAMS/Test_codes/seeing_psf.py @@ -0,0 +1,123 @@ +import os +import pytest +import numpy as np +from astropy.io.fits import HDUList +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +import scopesim +from astropy.convolution import Gaussian2DKernel +from scopesim import rc +from scopesim_templates.stellar import star_field, star_grid +import scopesim_templates as sim_tp +from scopesim.optics.fov_manager import FOVManager +from astropy import units as u +from scopesim.utils import quantify + +PLOTS = True + +if rc.__config__["!SIM.tests.run_integration_tests"] is False: + pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") + +# Set TOP_PATH to the directory containing the DREAMS package +TOP_PATH = "/Users/anjali/github" +rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH + +# Adjust the PKGS dictionary to reflect the correct path +PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} + +# Verify the path to the DREAMS package +if not os.path.exists(PKGS["DREAMS"]): + raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") +else: + print("DREAMS package found at:", PKGS["DREAMS"]) + +dreams = scopesim.OpticalTrain("DREAMS") +assert isinstance(dreams, scopesim.OpticalTrain) +print("scopesim package loaded successfully.") + +# Create a star field as the source +src = star_field(500, 10, 20, width=100) + +# Set up user commands for the DREAMS simulation +cmds = scopesim.UserCommands(use_instrument="DREAMS") +cmds["!OBS.dit"] = 8 +cmds["!OBS.ndit"] = 1 +cmds["!DET.bin_size"] = 1 +cmds["!OBS.sky.bg_mag"] = 14.9 # J-band magnitude +cmds["!OBS.sky.filter_name"] = "J" +cmds["SIM.sub_pixel.flag"] = True + +dreams = scopesim.OpticalTrain(cmds) +dreams["detector_linearity"].include = False + +# Set up the Field of View (FOV) for the simulation +dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) +dreams.fov_manager.volumes_list[0]["x_min"] = -18000 +dreams.fov_manager.volumes_list[0]["x_max"] = 18000 +dreams.fov_manager.volumes_list[0]["y_min"] = -18000 +dreams.fov_manager.volumes_list[0]["y_max"] = 18000 +dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) + +# Perform observation +dreams.observe(src, update=False) +hdus = dreams.readout("uncrowded.fits") +print(f"Observation completed. HDUList type: {type(hdus[0])}") + +# ---------------------------------------------------- +# Define and Plot the SeeingPSF in Arcseconds +# ---------------------------------------------------- +class SeeingPSF: + """ + Gaussian kernel for seeing-limited PSF. + """ + + def __init__(self, fwhm=1.5): + self.fwhm = fwhm # FWHM in arcseconds + + def get_kernel(self, pixel_scale): + """ + Calculate Gaussian kernel for the given pixel scale and FWHM. + + Parameters: + ----------- + pixel_scale : float + The pixel scale in arcseconds/pixel. + + Returns: + -------- + kernel : np.ndarray + The Gaussian PSF kernel. + """ + sigma = self.fwhm / 2.35 / pixel_scale + kernel = Gaussian2DKernel(sigma, mode="center").array + kernel /= np.sum(kernel) # Normalize the kernel + return kernel + + def plot(self, pixel_scale): + """ + Plot the Seeing PSF in arcseconds using Matplotlib. + """ + kernel = self.get_kernel(pixel_scale) + + # Define axis values in arcseconds instead of pixels + size = kernel.shape[0] # Assuming the kernel is square + arcsec_extent = size * pixel_scale / 2 # Half the extent for centered plot + x = np.linspace(-arcsec_extent, arcsec_extent, size) + y = np.linspace(-arcsec_extent, arcsec_extent, size) + + plt.figure(figsize=(6, 6)) + plt.imshow(kernel, origin='lower', extent=[x[0], x[-1], y[0], y[-1]], cmap='plasma', norm=LogNorm()) + #plt.contour(x, y, kernel, colors='white', linewidths=0.5) # Add contours + + plt.colorbar(label='Intensity') + plt.title(f"Seeing PSF (FWHM = {self.fwhm} arcsec") + plt.xlabel("X [arcseconds]") + plt.ylabel("Y [arcseconds]") + plt.show() + +# Set the pixel scale and FWHM +pixel_scale = 2.48 # Pixel scale of 2.48 arcseconds per pixel +seeing_psf = SeeingPSF(fwhm=5) # Set FWHM to 5 arcseconds + +# Plot the SeeingPSF with arcseconds on the axes +seeing_psf.plot(pixel_scale=pixel_scale) From fc7bc63bf36f85f381c420312cb603764b5137a5 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Wed, 2 Oct 2024 01:27:07 +1000 Subject: [PATCH 27/43] Create Vibration_psf.py --- DREAMS/Test_codes/Vibration_psf.py | 172 +++++++++++++++++++++++++++++ 1 file changed, 172 insertions(+) create mode 100644 DREAMS/Test_codes/Vibration_psf.py diff --git a/DREAMS/Test_codes/Vibration_psf.py b/DREAMS/Test_codes/Vibration_psf.py new file mode 100644 index 00000000..17ee55e0 --- /dev/null +++ b/DREAMS/Test_codes/Vibration_psf.py @@ -0,0 +1,172 @@ +import os +import warnings +import numpy as np +from astropy import units as u +from astropy.io.fits import HDUList +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +import scopesim +from astropy.convolution import Gaussian2DKernel +from scopesim.utils import quantify +from scopesim import rc +from scopesim_templates.stellar import star_field, star_grid +from scopesim.optics.fov_manager import FOVManager + +print("Done with all the library installation") + + + +PLOTS = True + +# ---------------------------------------------------- +# Define VibrationPSF for vibration-affected PSF +# ---------------------------------------------------- + +class VibrationPSF: + """ + Gaussian kernel for vibration-affected PSF. + Produces an elongated PSF along the vibration axis. + """ + + def __init__(self, fwhm=5.0, amplitude=1.5, vibration_axis="x"): + """ + Initialize the Vibration PSF for telescope vibrations. + + Parameters: + ----------- + fwhm : float + Full width at half maximum (FWHM) of the PSF in arcseconds. + amplitude : float + Amplitude of the vibration effect, controlling elongation of the PSF. + vibration_axis : str + Axis along which vibration occurs, either "x" or "y". + """ + self.fwhm = fwhm # FWHM in arcseconds + self.amplitude = amplitude # Vibration amplitude controlling the elongation + self.vibration_axis = vibration_axis # Vibration axis ("x" or "y") + + def get_kernel(self, pixel_scale): + """ + Calculate the vibration-affected Gaussian kernel. + + Parameters: + ----------- + pixel_scale : float + The pixel scale in arcseconds per pixel. + + Returns: + -------- + kernel : np.ndarray + The vibration-affected PSF kernel. + """ + # Convert FWHM to standard deviation (sigma) in pixels + sigma = self.fwhm / 2.35 / pixel_scale + + # Adjust sigma based on the vibration axis and amplitude + if self.vibration_axis == "x": + sigma_x = sigma * self.amplitude # Elongated along the x-axis + sigma_y = sigma # Normal along the y-axis + else: + sigma_x = sigma # Normal along the x-axis + sigma_y = sigma * self.amplitude # Elongated along the y-axis + + # Create a 2D Gaussian kernel with vibration effect + kernel = Gaussian2DKernel(x_stddev=sigma_x, y_stddev=sigma_y, mode="center").array + kernel /= np.sum(kernel) # Normalize the kernel to have unit sum + + return kernel + + def plot(self, pixel_scale): + """ + Plot the Vibration-affected PSF using Matplotlib. + + Parameters: + ----------- + pixel_scale : float + The pixel scale in arcseconds per pixel. + """ + kernel = self.get_kernel(pixel_scale) + + # Define axis values in arcseconds instead of pixels + size = kernel.shape[0] # Assuming the kernel is square + arcsec_extent = size * pixel_scale / 2 # Half the extent for centered plot + x = np.linspace(-arcsec_extent, arcsec_extent, size) + y = np.linspace(-arcsec_extent, arcsec_extent, size) + + plt.figure(figsize=(8, 6)) + plt.imshow(kernel, origin='lower', extent=[x[0], x[-1], y[0], y[-1]], cmap='plasma',norm=LogNorm(vmin=1e-6, vmax=1)) # Adjust vmin and vmax as necessary + plt.colorbar(label='Intensity') + plt.title(f"Vibration PSF (FWHM = {self.fwhm} arcsec, Axis = {self.vibration_axis})") + plt.xlabel("X [arcseconds]") + plt.ylabel("Y [arcseconds]") + plt.gca().set_aspect('equal', adjustable='box') # Equal aspect ratio + plt.grid(False) # Optional: disable grid for clarity + plt.show() + + +# ---------------------------------------------------- +# DREAMS Simulation Setup +# ---------------------------------------------------- + +if rc.__config__["!SIM.tests.run_integration_tests"] is False: + pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") + +# Set TOP_PATH to the directory containing the DREAMS package +TOP_PATH = "/Users/anjali/github" +rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH + +# Adjust the PKGS dictionary to reflect the correct path +PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} + +# Verify the path to the DREAMS package +if not os.path.exists(PKGS["DREAMS"]): + raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") +else: + print("DREAMS package found at:", PKGS["DREAMS"]) + +# Initialize DREAMS optical train +dreams = scopesim.OpticalTrain("DREAMS") +assert isinstance(dreams, scopesim.OpticalTrain) +print("scopesim package loaded successfully.") + +# Create a star field as the source +src = star_field(500, 10, 20, width=100) + +# Set up user commands for the DREAMS simulation +cmds = scopesim.UserCommands(use_instrument="DREAMS") +cmds["!OBS.dit"] = 8 +cmds["!OBS.ndit"] = 1 +cmds["!DET.bin_size"] = 1 +cmds["!OBS.sky.bg_mag"] = 14.9 # J-band magnitude +cmds["!OBS.sky.filter_name"] = "J" +cmds["SIM.sub_pixel.flag"] = True + +# Reinitialize the optical train with the user commands +dreams = scopesim.OpticalTrain(cmds) +dreams["detector_linearity"].include = False + +# Set up the Field of View (FOV) for the simulation +dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) +dreams.fov_manager.volumes_list[0]["x_min"] = -18000 +dreams.fov_manager.volumes_list[0]["x_max"] = 18000 +dreams.fov_manager.volumes_list[0]["y_min"] = -18000 +dreams.fov_manager.volumes_list[0]["y_max"] = 18000 +dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) + +# Perform observation +dreams.observe(src, update=False) +hdus = dreams.readout("vibration_analysis.fits") +print(f"Observation completed. HDUList type: {type(hdus[0])}") + +# ---------------------------------------------------- +# Apply the VibrationPSF to DREAMS Simulation Results +# ---------------------------------------------------- + +# Define the pixel scale for DREAMS +pixel_scale = 2.48 # Arcseconds per pixel for DREAMS + +# Instantiate the VibrationPSF class +vibration_psf = VibrationPSF(fwhm=5, amplitude=1.5, vibration_axis="x") # Elongation along the x-axis + +# Plot the vibration-affected PSF +vibration_psf.plot(pixel_scale=pixel_scale) From 9f11a9d2cc73cde3e1bd092b4a2de259139e8c5a Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Wed, 2 Oct 2024 12:31:16 +1000 Subject: [PATCH 28/43] Create GaussianDiffractionPSF.py --- DREAMS/Test_codes/GaussianDiffractionPSF.py | 120 ++++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 DREAMS/Test_codes/GaussianDiffractionPSF.py diff --git a/DREAMS/Test_codes/GaussianDiffractionPSF.py b/DREAMS/Test_codes/GaussianDiffractionPSF.py new file mode 100644 index 00000000..8d93cfe9 --- /dev/null +++ b/DREAMS/Test_codes/GaussianDiffractionPSF.py @@ -0,0 +1,120 @@ +import os +import warnings +import numpy as np +from astropy import units as u +from astropy.io.fits import HDUList +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +import scopesim +from astropy.convolution import Gaussian2DKernel +from scopesim.utils import quantify +from scopesim import rc +from scopesim_templates.stellar import star_field, star_grid +from scopesim.optics.fov_manager import FOVManager + +PLOTS = True +class GaussianDiffractionPSF: + def __init__(self, diameter=0.1, **kwargs): # Default diameter is 0.1 m + self.meta = {"diameter": diameter, "z_order": [242, 642]} + self.required_keys = {"pixel_scale"} + self.valid_waverange = [0.1 * u.um, 0.2 * u.um] # Default wavelength range + + def update(self, **kwargs): + if "diameter" in kwargs: + self.meta["diameter"] = kwargs["diameter"] + + def get_kernel(self, pixel_scale): + wave_min = self.valid_waverange[0].value # Using default min wave + wave_max = self.valid_waverange[1].value # Using default max wave + wave = 0.5 * (wave_max + wave_min) # Average wave + wave = quantify(wave, u.um) + + diameter = quantify(self.meta["diameter"], u.m).to(u.um) + fwhm = 1.22 * (wave / diameter) * u.rad.to(u.arcsec) / pixel_scale + + sigma = fwhm.value / 2.35 + kernel = Gaussian2DKernel(sigma, mode="center").array + kernel /= np.sum(kernel) + + return kernel + + def plot(self, pixel_scale): + kernel = self.get_kernel(pixel_scale) + + size = kernel.shape[0] + arcsec_extent = size * pixel_scale / 2 + x = np.linspace(-arcsec_extent, arcsec_extent, size) + y = np.linspace(-arcsec_extent, arcsec_extent, size) + + plt.figure(figsize=(8, 6)) + plt.imshow(kernel, origin='lower', extent=[x[0], x[-1], y[0], y[-1]], cmap='plasma', norm=LogNorm(vmin=1e-6, vmax=1)) + plt.colorbar(label='Intensity') + plt.title(f"Gaussian Diffraction PSF (Diameter = {self.meta['diameter']} m)") + plt.xlabel("X [arcseconds]") + plt.ylabel("Y [arcseconds]") + plt.gca().set_aspect('equal', adjustable='box') + plt.grid(False) + plt.show() +if rc.__config__["!SIM.tests.run_integration_tests"] is False: + pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") + +# Set TOP_PATH to the directory containing the DREAMS package +TOP_PATH = "/Users/anjali/github" +rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH + +# Adjust the PKGS dictionary to reflect the correct path +PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} + +# Verify the path to the DREAMS package +if not os.path.exists(PKGS["DREAMS"]): + raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") +else: + print("DREAMS package found at:", PKGS["DREAMS"]) + +# Initialize DREAMS optical train +dreams = scopesim.OpticalTrain("DREAMS") +assert isinstance(dreams, scopesim.OpticalTrain) +print("scopesim package loaded successfully.") + +# Create a star field as the source +src = star_field(500, 10, 20, width=100) + +# Set up user commands for the DREAMS simulation +cmds = scopesim.UserCommands(use_instrument="DREAMS") +cmds["!OBS.dit"] = 8 +cmds["!OBS.ndit"] = 1 +cmds["!DET.bin_size"] = 1 +cmds["!OBS.sky.bg_mag"] = 14.9 # J-band magnitude +cmds["!OBS.sky.filter_name"] = "J" +cmds["SIM.sub_pixel.flag"] = True + +# Reinitialize the optical train with the user commands +dreams = scopesim.OpticalTrain(cmds) +dreams["detector_linearity"].include = False + +# Set up the Field of View (FOV) for the simulation +dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) +dreams.fov_manager.volumes_list[0]["x_min"] = -18000 +dreams.fov_manager.volumes_list[0]["x_max"] = 18000 +dreams.fov_manager.volumes_list[0]["y_min"] = -18000 +dreams.fov_manager.volumes_list[0]["y_max"] = 18000 +dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) + +# Perform observation +dreams.observe(src, update=False) +hdus = dreams.readout("vibration_analysis.fits") +print(f"Observation completed. HDUList type: {type(hdus[0])}") + + +# Define the pixel scale for DREAMS +pixel_scale = 2.48 # Arcseconds per pixel for DREAMS + +# Instantiate the VibrationPSF class +diffraction_psf = GaussianDiffractionPSF(diameter=0.5) + +# Get the PSF kernel for a specific pixel scale +pixel_scale = 2.48 # in arcseconds +kernel = diffraction_psf.get_kernel(pixel_scale) + +# Plot the PSF +diffraction_psf.plot(pixel_scale) From ef7de2a5a4dcee74c7da8fdc06e75d2d57d22b92 Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Wed, 2 Oct 2024 13:38:33 +1000 Subject: [PATCH 29/43] Update GaussianDiffractionPSF.py --- DREAMS/Test_codes/GaussianDiffractionPSF.py | 80 ++++----------------- 1 file changed, 14 insertions(+), 66 deletions(-) diff --git a/DREAMS/Test_codes/GaussianDiffractionPSF.py b/DREAMS/Test_codes/GaussianDiffractionPSF.py index 8d93cfe9..cad84dcf 100644 --- a/DREAMS/Test_codes/GaussianDiffractionPSF.py +++ b/DREAMS/Test_codes/GaussianDiffractionPSF.py @@ -1,33 +1,35 @@ import os -import warnings import numpy as np from astropy import units as u -from astropy.io.fits import HDUList from matplotlib import pyplot as plt from matplotlib.colors import LogNorm -import scopesim from astropy.convolution import Gaussian2DKernel from scopesim.utils import quantify from scopesim import rc -from scopesim_templates.stellar import star_field, star_grid +from scopesim_templates.stellar import star_field from scopesim.optics.fov_manager import FOVManager +# Set plotting flag PLOTS = True + +# GaussianDiffractionPSF Class class GaussianDiffractionPSF: def __init__(self, diameter=0.1, **kwargs): # Default diameter is 0.1 m self.meta = {"diameter": diameter, "z_order": [242, 642]} self.required_keys = {"pixel_scale"} - self.valid_waverange = [0.1 * u.um, 0.2 * u.um] # Default wavelength range + self.valid_waverange = [11610.0 * u.angstrom.to(u.micron), # Min wavelength in microns + 13330.0 * u.angstrom.to(u.micron)] # Max wavelength in microns def update(self, **kwargs): if "diameter" in kwargs: self.meta["diameter"] = kwargs["diameter"] def get_kernel(self, pixel_scale): - wave_min = self.valid_waverange[0].value # Using default min wave - wave_max = self.valid_waverange[1].value # Using default max wave + wave_min = 11610.0 * u.angstrom.to(u.micron) # Using J band min wave + wave_max =13330.0 * u.angstrom.to(u.micron) # Using J band max wave wave = 0.5 * (wave_max + wave_min) # Average wave wave = quantify(wave, u.um) + diameter = quantify(self.meta["diameter"], u.m).to(u.um) fwhm = 1.22 * (wave / diameter) * u.rad.to(u.arcsec) / pixel_scale @@ -49,72 +51,18 @@ def plot(self, pixel_scale): plt.figure(figsize=(8, 6)) plt.imshow(kernel, origin='lower', extent=[x[0], x[-1], y[0], y[-1]], cmap='plasma', norm=LogNorm(vmin=1e-6, vmax=1)) plt.colorbar(label='Intensity') - plt.title(f"Gaussian Diffraction PSF (Diameter = {self.meta['diameter']} m)") + plt.title(f"Gaussian Diffraction PSF (Diameter = {self.meta['diameter']} m, J Band Wavelength)") plt.xlabel("X [arcseconds]") plt.ylabel("Y [arcseconds]") plt.gca().set_aspect('equal', adjustable='box') plt.grid(False) plt.show() -if rc.__config__["!SIM.tests.run_integration_tests"] is False: - pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") - -# Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/github" -rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH - -# Adjust the PKGS dictionary to reflect the correct path -PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} - -# Verify the path to the DREAMS package -if not os.path.exists(PKGS["DREAMS"]): - raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") -else: - print("DREAMS package found at:", PKGS["DREAMS"]) - -# Initialize DREAMS optical train -dreams = scopesim.OpticalTrain("DREAMS") -assert isinstance(dreams, scopesim.OpticalTrain) -print("scopesim package loaded successfully.") - -# Create a star field as the source -src = star_field(500, 10, 20, width=100) - -# Set up user commands for the DREAMS simulation -cmds = scopesim.UserCommands(use_instrument="DREAMS") -cmds["!OBS.dit"] = 8 -cmds["!OBS.ndit"] = 1 -cmds["!DET.bin_size"] = 1 -cmds["!OBS.sky.bg_mag"] = 14.9 # J-band magnitude -cmds["!OBS.sky.filter_name"] = "J" -cmds["SIM.sub_pixel.flag"] = True - -# Reinitialize the optical train with the user commands -dreams = scopesim.OpticalTrain(cmds) -dreams["detector_linearity"].include = False - -# Set up the Field of View (FOV) for the simulation -dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) -dreams.fov_manager.volumes_list[0]["x_min"] = -18000 -dreams.fov_manager.volumes_list[0]["x_max"] = 18000 -dreams.fov_manager.volumes_list[0]["y_min"] = -18000 -dreams.fov_manager.volumes_list[0]["y_max"] = 18000 -dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) - -# Perform observation -dreams.observe(src, update=False) -hdus = dreams.readout("vibration_analysis.fits") -print(f"Observation completed. HDUList type: {type(hdus[0])}") - # Define the pixel scale for DREAMS pixel_scale = 2.48 # Arcseconds per pixel for DREAMS -# Instantiate the VibrationPSF class -diffraction_psf = GaussianDiffractionPSF(diameter=0.5) - -# Get the PSF kernel for a specific pixel scale -pixel_scale = 2.48 # in arcseconds -kernel = diffraction_psf.get_kernel(pixel_scale) +# Instantiate the GaussianDiffractionPSF class +gaussian_psf = GaussianDiffractionPSF(diameter=0.5) -# Plot the PSF -diffraction_psf.plot(pixel_scale) +# Plot the Gaussian Diffraction PSF +gaussian_psf.plot(pixel_scale) From 54958db5cc201f9b939fad746c6773ac484c62db Mon Sep 17 00:00:00 2001 From: Anjali_Shivani <114407895+Astrogirlanajli@users.noreply.github.com> Date: Wed, 2 Oct 2024 14:00:14 +1000 Subject: [PATCH 30/43] Create noncommonpathabbreation.py --- DREAMS/Test_codes/noncommonpathabbreation.py | 114 +++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 DREAMS/Test_codes/noncommonpathabbreation.py diff --git a/DREAMS/Test_codes/noncommonpathabbreation.py b/DREAMS/Test_codes/noncommonpathabbreation.py new file mode 100644 index 00000000..d6642ff9 --- /dev/null +++ b/DREAMS/Test_codes/noncommonpathabbreation.py @@ -0,0 +1,114 @@ +import os +import warnings +import numpy as np +from astropy import units as u +from astropy.convolution import Gaussian2DKernel +from scopesim.utils import from_currsys, quantify, quantity_from_table, figure_factory, check_keys +from scopesim.base_classes import ImagePlaneBase, FieldOfViewBase +from scopesim.effects import PSF, PoorMansFOV + +from astropy.io.fits import HDUList +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +import scopesim +from scopesim.utils import quantify +from scopesim import rc +from scopesim_templates.stellar import star_field, star_grid +from scopesim.optics.fov_manager import FOVManager + + + +print("Done with all the library installation") + +PLOTS = True + +class AnalyticalPSF(PSF): + """Base class for analytical PSFs.""" + + def __init__(self, **kwargs): + super().__init__(**kwargs) + self.meta["z_order"] = [41, 641] + self.convolution_classes = FieldOfViewBase + + +class NonCommonPathAberration(AnalyticalPSF): + """ + Non-Common Path Aberration class. + + Needed: pixel_scale + Accepted: kernel_width, strehl_drift + """ + + required_keys = {"pixel_scale"} + + def __init__(self, diameter, wave_min, wave_max, pixel_scale, **kwargs): + super().__init__(**kwargs) + self.meta["z_order"] = [241, 641] + self.meta["kernel_width"] = None + self.meta["strehl_drift"] = 0.02 + self.meta["wave_min"] = wave_min # Set the wave_min directly + self.meta["wave_max"] = wave_max # Set the wave_max directly + + self._total_wfe = None + self.valid_waverange = [wave_min * u.um, wave_max * u.um] + + self.convolution_classes = FieldOfViewBase + check_keys(self.meta, self.required_keys, action="error") + + def get_kernel(self, pixel_scale): + waves = (self.meta["wave_min"], self.meta["wave_max"]) + + old_waves = self.valid_waverange + wave_mid_old = 0.5 * (old_waves[0] + old_waves[1]) + wave_mid_new = 0.5 * (waves[0] + waves[1]) + strehl_old = wfe2strehl(wfe=self.total_wfe, wave=wave_mid_old) + strehl_new = wfe2strehl(wfe=self.total_wfe, wave=wave_mid_new) + + if np.abs(1 - strehl_old / strehl_new) > self.meta["strehl_drift"]: + self.valid_waverange = waves + self.kernel = wfe2gauss(wfe=self.total_wfe, wave=wave_mid_new, + width=self.meta["kernel_width"]) + self.kernel /= np.sum(self.kernel) + + return self.kernel + + def plot(self, pixel_scale): + """ + Plot the Vibration-affected PSF using Matplotlib. + + Parameters: + ----------- + pixel_scale : float + The pixel scale in arcseconds per pixel. + """ + kernel = self.get_kernel(pixel_scale) + + # Define axis values in arcseconds instead of pixels + size = kernel.shape[0] # Assuming the kernel is square + arcsec_extent = size * pixel_scale / 2 # Half the extent for centered plot + x = np.linspace(-arcsec_extent, arcsec_extent, size) + y = np.linspace(-arcsec_extent, arcsec_extent, size) + + plt.figure(figsize=(8, 6)) + plt.imshow(kernel, origin='lower', extent=[x[0], x[-1], y[0], y[-1]], cmap='plasma', norm=LogNorm(vmin=1e-6, vmax=1)) # Adjust vmin and vmax as necessary + plt.colorbar(label='Intensity') + plt.title(f"Non-Common Path Aberration PSF (Diameter = {diameter} m)") + plt.xlabel("X [arcseconds]") + plt.ylabel("Y [arcseconds]") + plt.gca().set_aspect('equal', adjustable='box') # Equal aspect ratio + plt.grid(False) # Optional: disable grid for clarity + plt.show() + +# Rest of your setup code... + +# Initialize the NonCommonPathAberration class +npc_psf = NonCommonPathAberration( + diameter=0.5, + wave_min=0.01161, + wave_max=0.01333, + pixel_scale=2.48 +) + +# Plot the Aberration affected PSF +npc_psf.plot(pixel_scale=2.48) + From b021e65d5cbdba9f278b3d4c4296e652849c3c56 Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 21:55:22 +0200 Subject: [PATCH 31/43] Remove unnecessary files --- DREAMS/SECURITY.md | 21 --------------------- DREAMS/Test_codes/.DS_Store | Bin 6148 -> 0 bytes DREAMS/filters/.DS_Store | Bin 6148 -> 0 bytes DREAMS/main/.DS_Store | Bin 6148 -> 0 bytes 4 files changed, 21 deletions(-) delete mode 100644 DREAMS/SECURITY.md delete mode 100644 DREAMS/Test_codes/.DS_Store delete mode 100644 DREAMS/filters/.DS_Store delete mode 100644 DREAMS/main/.DS_Store diff --git a/DREAMS/SECURITY.md b/DREAMS/SECURITY.md deleted file mode 100644 index 034e8480..00000000 --- a/DREAMS/SECURITY.md +++ /dev/null @@ -1,21 +0,0 @@ -# Security Policy - -## Supported Versions - -Use this section to tell people about which versions of your project are -currently being supported with security updates. - -| Version | Supported | -| ------- | ------------------ | -| 5.1.x | :white_check_mark: | -| 5.0.x | :x: | -| 4.0.x | :white_check_mark: | -| < 4.0 | :x: | - -## Reporting a Vulnerability - -Use this section to tell people how to report a vulnerability. - -Tell them where to go, how often they can expect to get an update on a -reported vulnerability, what to expect if the vulnerability is accepted or -declined, etc. diff --git a/DREAMS/Test_codes/.DS_Store b/DREAMS/Test_codes/.DS_Store deleted file mode 100644 index 81340ce5af1396e360e3a33a3a1da08d886a5f8e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHK!Ab)$6r5L!Zt11oya@3Jip7h^rB*~xr1$}~wG|4BEn2}IguVJTo;>+W{)5g- zV!Ng5Rf@b~eJe%CE zv8`bf9niH)Fha)Pm}|FKzd<$`uuuOOUFPvu4A$$oBUd#;@>Mm*JqEh!OOlsFwnkD9Xr(z|4wwTA z2lV~mn2Kq{JfMGdu<%C!VwKH4Sl3TR)wqah#5^E-7!st!AeDH;kRWHfi@Y>q9x%uu z@$eyWW{D>h@w0P$=jo6%pq1u;Ik4)$R=8~F{(t)W`F~YpSLT2@@UI+@YUjGs<|DK`=(Ts>DXo4(*0h8rH*O8OQK-L_OtG3%TZPyH>`JGF$_c7hj zoVN5p`}>C^d=2k;ucq6df_X;`wbapucEeHh3huK-^}Xg_9bmq}dsZ>m2bh;&&a0iQ zzp;}GM7`|g$22Sy2n9lcP~hJyfIC}kGBu1o6bJ=EflmeGd`M`5*|8Yv(Sc4&0N@DA zY8Xo`Au-7@I~GHDU~Hj43uP}c*ut@%oR=Mop@kEB@xlJ&kK%>(>BygyPMi&+4+TPj zT7hGm&gA~T!Y4CW1YvSTrnEV8cQ!1xhRL81!uvSo#m0%oOs zWAE>HjT(aL~6L9yxKB1%bU;aBqJ42?HRjmv%2s1hgs$EfN?9ilC3<- z^MtRL=i}VI@4EG_Un5q(Uw<@D&D+g1zxgqLco@CgDVQ`WKn17(6`%tDQvvjBv-&KM zD;1yuRNz|yJ0A+%uuU8S{pi5rBLL8TPpo@2CJ3_)`jK)vdZE zJ}GB Date: Wed, 15 Oct 2025 22:06:15 +0200 Subject: [PATCH 32/43] Add inst_pkgs symlink --- DREAMS/Test_codes/inst_pkgs | 1 + 1 file changed, 1 insertion(+) create mode 120000 DREAMS/Test_codes/inst_pkgs diff --git a/DREAMS/Test_codes/inst_pkgs b/DREAMS/Test_codes/inst_pkgs new file mode 120000 index 00000000..c25bddb6 --- /dev/null +++ b/DREAMS/Test_codes/inst_pkgs @@ -0,0 +1 @@ +../.. \ No newline at end of file From 5024e9e20e7772331d7ec813da56b1a6bfaa9a3f Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 22:06:53 +0200 Subject: [PATCH 33/43] Remove now unnecessary references to specific path --- DREAMS/Test_codes/Galaxy.py | 13 ------------- DREAMS/Test_codes/LMC.py | 13 ------------- DREAMS/Test_codes/Lc.py | 13 ------------- DREAMS/Test_codes/Vibration_psf.py | 13 ------------- DREAMS/Test_codes/ellip.py | 13 ------------- DREAMS/Test_codes/seeing_psf.py | 13 ------------- DREAMS/Test_codes/star_1.py | 13 ------------- DREAMS/Test_codes/testt.py | 13 ------------- 8 files changed, 104 deletions(-) diff --git a/DREAMS/Test_codes/Galaxy.py b/DREAMS/Test_codes/Galaxy.py index f76e5c38..3eb50813 100644 --- a/DREAMS/Test_codes/Galaxy.py +++ b/DREAMS/Test_codes/Galaxy.py @@ -20,19 +20,6 @@ if rc.__config__["!SIM.tests.run_integration_tests"] is False: pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") -# Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/github" -rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH - -# Adjust the PKGS dictionary to reflect the correct path -PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} - -# Verify the path to the DREAMS package -if not os.path.exists(PKGS["DREAMS"]): - raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") -else: - print("DREAMS package found at:", PKGS["DREAMS"]) - cmds = scopesim.UserCommands(use_instrument="DREAMS") cmds["!OBS.dit"] = 1000 cmds["!OBS.ndit"] = 1000 diff --git a/DREAMS/Test_codes/LMC.py b/DREAMS/Test_codes/LMC.py index 9b3e8cfb..8851ca34 100644 --- a/DREAMS/Test_codes/LMC.py +++ b/DREAMS/Test_codes/LMC.py @@ -21,19 +21,6 @@ if rc.__config__["!SIM.tests.run_integration_tests"] is False: pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") -# Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/github" -rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH - -# Adjust the PKGS dictionary to reflect the correct path -PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} - -# Verify the path to the DREAMS package -if not os.path.exists(PKGS["DREAMS"]): - raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") -else: - print("DREAMS package found at:", PKGS["DREAMS"]) - cmds = scopesim.UserCommands(use_instrument="DREAMS") cmds["!OBS.dit"] = 1000 cmds["!OBS.ndit"] = 1000 diff --git a/DREAMS/Test_codes/Lc.py b/DREAMS/Test_codes/Lc.py index 132f5bbf..368293d3 100644 --- a/DREAMS/Test_codes/Lc.py +++ b/DREAMS/Test_codes/Lc.py @@ -23,19 +23,6 @@ if rc.__config__["!SIM.tests.run_integration_tests"] is False: pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") -# Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/github" -rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH - -# Adjust the PKGS dictionary to reflect the correct path -PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} - -# Verify the path to the DREAMS package -if not os.path.exists(PKGS["DREAMS"]): - raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") -else: - print("DREAMS package found at:", PKGS["DREAMS"]) - cmds = scopesim.UserCommands(use_instrument="DREAMS") cmds["!OBS.dit"] = 1000 cmds["!OBS.ndit"] = 1000 diff --git a/DREAMS/Test_codes/Vibration_psf.py b/DREAMS/Test_codes/Vibration_psf.py index 17ee55e0..a8b8b9db 100644 --- a/DREAMS/Test_codes/Vibration_psf.py +++ b/DREAMS/Test_codes/Vibration_psf.py @@ -111,19 +111,6 @@ def plot(self, pixel_scale): if rc.__config__["!SIM.tests.run_integration_tests"] is False: pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") -# Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/github" -rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH - -# Adjust the PKGS dictionary to reflect the correct path -PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} - -# Verify the path to the DREAMS package -if not os.path.exists(PKGS["DREAMS"]): - raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") -else: - print("DREAMS package found at:", PKGS["DREAMS"]) - # Initialize DREAMS optical train dreams = scopesim.OpticalTrain("DREAMS") assert isinstance(dreams, scopesim.OpticalTrain) diff --git a/DREAMS/Test_codes/ellip.py b/DREAMS/Test_codes/ellip.py index ef452f57..c77332c7 100644 --- a/DREAMS/Test_codes/ellip.py +++ b/DREAMS/Test_codes/ellip.py @@ -21,19 +21,6 @@ if rc.__config__["!SIM.tests.run_integration_tests"] is False: pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") -# Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/Desktop" -rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH - -# Adjust the PKGS dictionary to reflect the correct path -PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} - -# Verify the path to the DREAMS package -if not os.path.exists(PKGS["DREAMS"]): - raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") -else: - print("DREAMS package found at:", PKGS["DREAMS"]) - cmds = scopesim.UserCommands(use_instrument="DREAMS") cmds["!OBS.dit"] = 1000 cmds["!OBS.ndit"] = 1000 diff --git a/DREAMS/Test_codes/seeing_psf.py b/DREAMS/Test_codes/seeing_psf.py index 03a56c0c..d0740b5f 100644 --- a/DREAMS/Test_codes/seeing_psf.py +++ b/DREAMS/Test_codes/seeing_psf.py @@ -18,19 +18,6 @@ if rc.__config__["!SIM.tests.run_integration_tests"] is False: pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") -# Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/github" -rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH - -# Adjust the PKGS dictionary to reflect the correct path -PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} - -# Verify the path to the DREAMS package -if not os.path.exists(PKGS["DREAMS"]): - raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") -else: - print("DREAMS package found at:", PKGS["DREAMS"]) - dreams = scopesim.OpticalTrain("DREAMS") assert isinstance(dreams, scopesim.OpticalTrain) print("scopesim package loaded successfully.") diff --git a/DREAMS/Test_codes/star_1.py b/DREAMS/Test_codes/star_1.py index c6497145..f311ac7e 100644 --- a/DREAMS/Test_codes/star_1.py +++ b/DREAMS/Test_codes/star_1.py @@ -20,19 +20,6 @@ if rc.__config__["!SIM.tests.run_integration_tests"] is False: pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") -# Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/Desktop" -rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH - -# Adjust the PKGS dictionary to reflect the correct path -PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} - -# Verify the path to the DREAMS package -if not os.path.exists(PKGS["DREAMS"]): - raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") -else: - print("DREAMS package found at:", PKGS["DREAMS"]) - cmds = scopesim.UserCommands(use_instrument="DREAMS") cmds["!OBS.dit"] = 10 cmds["!DET.bin_size"] = 1 diff --git a/DREAMS/Test_codes/testt.py b/DREAMS/Test_codes/testt.py index 9bf0bcf3..7456ac36 100644 --- a/DREAMS/Test_codes/testt.py +++ b/DREAMS/Test_codes/testt.py @@ -16,19 +16,6 @@ if rc.__config__["!SIM.tests.run_integration_tests"] is False: pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") -# Set TOP_PATH to the directory containing the DREAMS package -TOP_PATH = "/Users/anjali/github" -rc.__config__["!SIM.file.local_packages_path"] = TOP_PATH - -# Adjust the PKGS dictionary to reflect the correct path -PKGS = {"DREAMS": os.path.join(TOP_PATH, "DREAMS")} - -# Verify the path to the DREAMS package -if not os.path.exists(PKGS["DREAMS"]): - raise FileNotFoundError(f"DREAMS package not found at {PKGS['DREAMS']}") -else: - print("DREAMS package found at:", PKGS["DREAMS"]) - class TestLoads: def test_scopesim_loads_package(self): dreams = scopesim.OpticalTrain("DREAMS") From 06ea578cf4ea840ac1769d46b78ce3cc9885a561 Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 22:13:04 +0200 Subject: [PATCH 34/43] Rename SummedExposure to ExposureIntegration --- DREAMS/DREAMS_InGaAs.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/DREAMS/DREAMS_InGaAs.yaml b/DREAMS/DREAMS_InGaAs.yaml index e59666ca..2c290ba3 100644 --- a/DREAMS/DREAMS_InGaAs.yaml +++ b/DREAMS/DREAMS_InGaAs.yaml @@ -29,9 +29,9 @@ effects: kwargs : filename : QE_InGaAs.dat -- name: exposure_action +- name: exposure_integration description: Summing up sky signal for all DITs and NDITs - class: SummedExposure + class: ExposureIntegration - name: dark_current description : SBIG dark current From d7c3fac7bfa4f05e9a49bcdec3a4b0627def6632 Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 22:17:41 +0200 Subject: [PATCH 35/43] Replace surfaces_table.throughput with system_transmission --- DREAMS/Test_codes/LMC.py | 2 +- DREAMS/Test_codes/Lc.py | 2 +- DREAMS/Test_codes/star_1.py | 2 +- DREAMS/Test_codes/testt.py | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/DREAMS/Test_codes/LMC.py b/DREAMS/Test_codes/LMC.py index 8851ca34..11be840a 100644 --- a/DREAMS/Test_codes/LMC.py +++ b/DREAMS/Test_codes/LMC.py @@ -48,7 +48,7 @@ #dreams.readout(filename="Han.fits") plt.subplot(121) wave = np.arange(3000, 11000) -plt.plot(wave, dreams.optics_manager.surfaces_table.throughput(wave)) +plt.plot(wave, dreams.optics_manager.system_transmission(wave)) plt.subplot(122) im = hdus[0][1].data # detector_order = [2, 1, 4, 3, 6, 5] diff --git a/DREAMS/Test_codes/Lc.py b/DREAMS/Test_codes/Lc.py index 368293d3..3dbe5380 100644 --- a/DREAMS/Test_codes/Lc.py +++ b/DREAMS/Test_codes/Lc.py @@ -50,7 +50,7 @@ dreams.readout(filename="Lc.fits") #plt.subplot(121) #wave = np.arange(3000, 11000) -#plt.plot(wave, dreams.optics_manager.surfaces_table.throughput(wave)) +#plt.plot(wave, dreams.optics_manager.system_transmission(wave)) plt.subplot(122) im = hdus[0][1].data plt.imshow(im, norm=LogNorm()) diff --git a/DREAMS/Test_codes/star_1.py b/DREAMS/Test_codes/star_1.py index f311ac7e..cb1f8d49 100644 --- a/DREAMS/Test_codes/star_1.py +++ b/DREAMS/Test_codes/star_1.py @@ -58,7 +58,7 @@ #dreams.readout(filename="Han.fits") plt.subplot(121) wave = np.arange(3000, 11000) -plt.plot(wave, dreams.optics_manager.surfaces_table.throughput(wave)) +plt.plot(wave, dreams.optics_manager.system_transmission(wave)) plt.subplot(122) im = hdus[0][1].data detector_order = [2, 1, 4, 3, 6, 5] diff --git a/DREAMS/Test_codes/testt.py b/DREAMS/Test_codes/testt.py index 7456ac36..049915af 100644 --- a/DREAMS/Test_codes/testt.py +++ b/DREAMS/Test_codes/testt.py @@ -68,7 +68,7 @@ def test_something_comes_out(self): if PLOTS: plt.subplot(121) wave = np.arange(3000, 11000) - plt.plot(wave, dreams.optics_manager.surfaces_table.throughput(wave)) + plt.plot(wave, dreams.optics_manager.system_transmission(wave)) plt.subplot(122) im = hdus[0][1].data From 5c23114d4ce99e5f84f8b6c3482ed85e57ec6e60 Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 22:34:50 +0200 Subject: [PATCH 36/43] Remove FOV-workaround that is now not necessary anymore. Fixed by https://github.com/AstarVienna/ScopeSim/pull/433. --- DREAMS/Test_codes/Galaxy.py | 12 ++---------- DREAMS/Test_codes/LMC.py | 10 +--------- DREAMS/Test_codes/Lc.py | 10 +--------- DREAMS/Test_codes/Vibration_psf.py | 10 +--------- DREAMS/Test_codes/ellip.py | 10 +--------- DREAMS/Test_codes/seeing_psf.py | 10 +--------- DREAMS/Test_codes/star_1.py | 10 +--------- DREAMS/Test_codes/testt.py | 20 +------------------- 8 files changed, 9 insertions(+), 83 deletions(-) diff --git a/DREAMS/Test_codes/Galaxy.py b/DREAMS/Test_codes/Galaxy.py index 3eb50813..7287ea2f 100644 --- a/DREAMS/Test_codes/Galaxy.py +++ b/DREAMS/Test_codes/Galaxy.py @@ -29,25 +29,17 @@ cmds["SIM.sub_pixel.flag"] = True dreams = scopesim.OpticalTrain(cmds) dreams["detector_linearity"].include = False -dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) -# Then make the initial field of view 10 times larges than normal. -dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec -dreams.fov_manager.volumes_list[0]["x_max"] = 18000 -dreams.fov_manager.volumes_list[0]["y_min"] = -18000 -dreams.fov_manager.volumes_list[0]["y_max"] = 18000 -# Finally, shrink the field of view to the detector size. -dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) print("scopesim package loaded successfully.") from scopesim_templates.extragalactic import galaxy src = galaxy("kc96/s0", z=1.5, amplitude=17, filter_curve="J", pixel_scale=0.01, r_eff=2.5, n=4, ellip=0.5, theta=45, extend=3) -dreams.observe(src, update=False) +dreams.observe(src) print("yessss anjali") hdus = dreams.readout() dreams.readout(filename="gal.fits") # Observe the source -dreams.observe(src, update=False) +dreams.observe(src) # Readout and plot hdus = dreams.readout() diff --git a/DREAMS/Test_codes/LMC.py b/DREAMS/Test_codes/LMC.py index 11be840a..8c02e732 100644 --- a/DREAMS/Test_codes/LMC.py +++ b/DREAMS/Test_codes/LMC.py @@ -30,19 +30,11 @@ cmds["SIM.sub_pixel.flag"] = True dreams = scopesim.OpticalTrain(cmds) dreams["detector_linearity"].include = False -dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) -# Then make the initial field of view 10 times larges than normal. -dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec -dreams.fov_manager.volumes_list[0]["x_max"] = 18000 -dreams.fov_manager.volumes_list[0]["y_min"] = -18000 -dreams.fov_manager.volumes_list[0]["y_max"] = 18000 -# Finally, shrink the field of view to the detector size. -dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) print("scopesim package loaded successfully.") src = sim_tp.stellar.clusters.cluster(mass=10000, distance=1800, core_radius=500, seed=9002) -dreams.observe(src, update=False) +dreams.observe(src) print("yessss anjali") hdus = dreams.readout() #dreams.readout(filename="Han.fits") diff --git a/DREAMS/Test_codes/Lc.py b/DREAMS/Test_codes/Lc.py index 3dbe5380..3e37bb18 100644 --- a/DREAMS/Test_codes/Lc.py +++ b/DREAMS/Test_codes/Lc.py @@ -32,19 +32,11 @@ cmds["SIM.sub_pixel.flag"] = True dreams = scopesim.OpticalTrain(cmds) dreams["detector_linearity"].include = False -dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) -# Then make the initial field of view 10 times larges than normal. -dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec -dreams.fov_manager.volumes_list[0]["x_max"] = 18000 -dreams.fov_manager.volumes_list[0]["y_min"] = -18000 -dreams.fov_manager.volumes_list[0]["y_max"] = 18000 -# Finally, shrink the field of view to the detector size. -dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) print("scopesim package loaded successfully.") src = cluster(mass=1000, distance=50000, core_radius=500, seed=9002) -dreams.observe(src, update=False) +dreams.observe(src) print("yessss anjali") hdus = dreams.readout() dreams.readout(filename="Lc.fits") diff --git a/DREAMS/Test_codes/Vibration_psf.py b/DREAMS/Test_codes/Vibration_psf.py index a8b8b9db..e4d38eb9 100644 --- a/DREAMS/Test_codes/Vibration_psf.py +++ b/DREAMS/Test_codes/Vibration_psf.py @@ -132,16 +132,8 @@ def plot(self, pixel_scale): dreams = scopesim.OpticalTrain(cmds) dreams["detector_linearity"].include = False -# Set up the Field of View (FOV) for the simulation -dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) -dreams.fov_manager.volumes_list[0]["x_min"] = -18000 -dreams.fov_manager.volumes_list[0]["x_max"] = 18000 -dreams.fov_manager.volumes_list[0]["y_min"] = -18000 -dreams.fov_manager.volumes_list[0]["y_max"] = 18000 -dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) - # Perform observation -dreams.observe(src, update=False) +dreams.observe(src) hdus = dreams.readout("vibration_analysis.fits") print(f"Observation completed. HDUList type: {type(hdus[0])}") diff --git a/DREAMS/Test_codes/ellip.py b/DREAMS/Test_codes/ellip.py index c77332c7..7004683b 100644 --- a/DREAMS/Test_codes/ellip.py +++ b/DREAMS/Test_codes/ellip.py @@ -30,18 +30,10 @@ cmds["SIM.sub_pixel.flag"] = True dreams = scopesim.OpticalTrain(cmds) dreams["detector_linearity"].include = False -dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) -# Then make the initial field of view 10 times larges than normal. -dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec -dreams.fov_manager.volumes_list[0]["x_max"] = 18000 -dreams.fov_manager.volumes_list[0]["y_min"] = -18000 -dreams.fov_manager.volumes_list[0]["y_max"] = 18000 -# Finally, shrink the field of view to the detector size. -dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) print("scopesim package loaded successfully.") src = elliptical(half_light_radius=11500, pixel_scale=2.48, filter_name="J", amplitude=17, normalization="total", n=4, ellipticity=0.5, angle=30) -dreams.observe(src, update=False) +dreams.observe(src) hdus = dreams.readout() dreams.readout(filename="ellip.fits") plt.subplot(122) diff --git a/DREAMS/Test_codes/seeing_psf.py b/DREAMS/Test_codes/seeing_psf.py index d0740b5f..16a2efca 100644 --- a/DREAMS/Test_codes/seeing_psf.py +++ b/DREAMS/Test_codes/seeing_psf.py @@ -37,16 +37,8 @@ dreams = scopesim.OpticalTrain(cmds) dreams["detector_linearity"].include = False -# Set up the Field of View (FOV) for the simulation -dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) -dreams.fov_manager.volumes_list[0]["x_min"] = -18000 -dreams.fov_manager.volumes_list[0]["x_max"] = 18000 -dreams.fov_manager.volumes_list[0]["y_min"] = -18000 -dreams.fov_manager.volumes_list[0]["y_max"] = 18000 -dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) - # Perform observation -dreams.observe(src, update=False) +dreams.observe(src) hdus = dreams.readout("uncrowded.fits") print(f"Observation completed. HDUList type: {type(hdus[0])}") diff --git a/DREAMS/Test_codes/star_1.py b/DREAMS/Test_codes/star_1.py index cb1f8d49..55ac0556 100644 --- a/DREAMS/Test_codes/star_1.py +++ b/DREAMS/Test_codes/star_1.py @@ -28,14 +28,6 @@ cmds["SIM.sub_pixel.flag"] = True dreams = scopesim.OpticalTrain(cmds) dreams["detector_linearity"].include = False -dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) -# Then make the initial field of view 10 times larges than normal. -dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec -dreams.fov_manager.volumes_list[0]["x_max"] = 18000 -dreams.fov_manager.volumes_list[0]["y_min"] = -18000 -dreams.fov_manager.volumes_list[0]["y_max"] = 18000 -# Finally, shrink the field of view to the detector size. -dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) print("scopesim package loaded successfully.") x, y = np.meshgrid(np.arange(100), np.arange(100)) @@ -52,7 +44,7 @@ sp = synphot.SourceSpectrum(synphot.Empirical1D, points=wave, lookup_table=bb(wave)) src = Source(image_hdu=hdu, spectra=sp) src.shift(10, 10) -dreams.observe(src, update=False) +dreams.observe(src) print("yessss anjali") hdus = dreams.readout() #dreams.readout(filename="Han.fits") diff --git a/DREAMS/Test_codes/testt.py b/DREAMS/Test_codes/testt.py index 049915af..cc6d191d 100644 --- a/DREAMS/Test_codes/testt.py +++ b/DREAMS/Test_codes/testt.py @@ -41,25 +41,7 @@ def test_something_comes_out(self): dreams = scopesim.OpticalTrain(cmds) dreams["detector_linearity"].include = False - # Hackish workaround to get a larger Field of View. - # This problem is fixed in https://github.com/AstarVienna/ScopeSim/pull/433 - # This hack can thus be removed once that is merged and a new - # ScopeSim version is released. - # First recreate the fov_manager without preloading the field of - # views with the wrong values. - dreams.fov_manager = FOVManager(dreams.optics_manager.fov_setup_effects, cmds=dreams.cmds, preload_fovs=False) - # Then make the initial field of view 10 times larges than normal. - dreams.fov_manager.volumes_list[0]["x_min"] = -18000 # arcsec - dreams.fov_manager.volumes_list[0]["x_max"] = 18000 - dreams.fov_manager.volumes_list[0]["y_min"] = -18000 - dreams.fov_manager.volumes_list[0]["y_max"] = 18000 - # Finally, shrink the field of view to the detector size. - dreams.fov_manager._fovs_list = list(dreams.fov_manager.generate_fovs_list()) - - # We now need to put update=False here, because otherwise the hacked - # fov_manager gets reinitialized. dreams can therefor only be used - # once, and needs to be recreated for the next simulation. - dreams.observe(src, update=False) + dreams.observe(src) hdus = dreams.readout("dreams.fits") From 29246f4e4737f3c9b9b36f487c250da9419dcd3d Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 22:44:34 +0200 Subject: [PATCH 37/43] Show something for the cluster --- DREAMS/Test_codes/testt.py | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/DREAMS/Test_codes/testt.py b/DREAMS/Test_codes/testt.py index cc6d191d..287b3aa3 100644 --- a/DREAMS/Test_codes/testt.py +++ b/DREAMS/Test_codes/testt.py @@ -62,13 +62,18 @@ def test_something_comes_out(self): plt.grid() plt.show() - #detector_order = [2, 1, 4, 3, 6, 5] - #plt.figure(figsize=(20, 20)) - #for plot_number, hdu_number in enumerate(detector_order, 1): - #plt.subplot(3, 2, plot_number) - #plt.imshow(hdus[0][hdu_number].data, origin="lower", norm=LogNorm()) - #plt.colorbar() - #plt.show() + detector_order = [2, 1, 4, 3, 6, 5] + plt.figure(figsize=(20, 20)) + for plot_number, hdu_number in enumerate(detector_order, 1): + plt.subplot(3, 2, plot_number) + data = hdus[0][hdu_number].data + med = np.median(data) + std = np.std(data) + vmin = med + vmax = med + 5 * std + plt.imshow(data, origin="lower", norm=LogNorm(vmin=vmin, vmax=vmax)) + plt.colorbar() + plt.show() @pytest.mark.slow def test_observes_from_scopesim_templates(self): From 3a073db02056ec42dd21d2fb47a265c228f94517 Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 22:47:46 +0200 Subject: [PATCH 38/43] Fix style --- DREAMS/Test_codes/testt.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/DREAMS/Test_codes/testt.py b/DREAMS/Test_codes/testt.py index 287b3aa3..e238512e 100644 --- a/DREAMS/Test_codes/testt.py +++ b/DREAMS/Test_codes/testt.py @@ -9,19 +9,20 @@ from scopesim import rc from scopesim.source.source_templates import star_field import scopesim_templates as sim_tp -from scopesim.optics.fov_manager import FOVManager PLOTS = True if rc.__config__["!SIM.tests.run_integration_tests"] is False: pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") + class TestLoads: def test_scopesim_loads_package(self): dreams = scopesim.OpticalTrain("DREAMS") assert isinstance(dreams, scopesim.OpticalTrain) # Corrected syntax print("scopesim package loaded successfully.") + class TestObserves: def test_something_comes_out(self): print("Starting observation test...") @@ -106,9 +107,12 @@ def test_saves_readout_to_disc(self): assert os.path.exists("GNANU.fits") print("Readout saved to GNANU.fits.") + def run_test_and_plot(): test_observes = TestObserves() test_observes.test_something_comes_out() + # Run the test and plot as soon as the module is imported -run_test_and_plot() +if __name__ == '__main__': + run_test_and_plot() From 60596e6631694a6918b8d17208591896da7c82c3 Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 22:48:33 +0200 Subject: [PATCH 39/43] Rename testt.py to cluster.py as it is more representative --- DREAMS/Test_codes/{testt.py => cluster.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename DREAMS/Test_codes/{testt.py => cluster.py} (100%) diff --git a/DREAMS/Test_codes/testt.py b/DREAMS/Test_codes/cluster.py similarity index 100% rename from DREAMS/Test_codes/testt.py rename to DREAMS/Test_codes/cluster.py From d64a57c3debf53ea2e194dbf5e39be38a5b2111e Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 22:54:01 +0200 Subject: [PATCH 40/43] Add bin_size to the default detector properties --- DREAMS/DREAMS_InGaAs.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/DREAMS/DREAMS_InGaAs.yaml b/DREAMS/DREAMS_InGaAs.yaml index 2c290ba3..2e8077e9 100644 --- a/DREAMS/DREAMS_InGaAs.yaml +++ b/DREAMS/DREAMS_InGaAs.yaml @@ -14,6 +14,8 @@ properties: height: 1024 x: 0 y: 0 + bin_size: 1 + effects: - name: full_detector_array description: THe full DREAMS detector array list From 82fb92fbe4add3a364b5e642af38f031a50f0e3e Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 23:07:24 +0200 Subject: [PATCH 41/43] Remove noncommonpathabbreation.py as it does not work --- DREAMS/Test_codes/noncommonpathabbreation.py | 114 ------------------- 1 file changed, 114 deletions(-) delete mode 100644 DREAMS/Test_codes/noncommonpathabbreation.py diff --git a/DREAMS/Test_codes/noncommonpathabbreation.py b/DREAMS/Test_codes/noncommonpathabbreation.py deleted file mode 100644 index d6642ff9..00000000 --- a/DREAMS/Test_codes/noncommonpathabbreation.py +++ /dev/null @@ -1,114 +0,0 @@ -import os -import warnings -import numpy as np -from astropy import units as u -from astropy.convolution import Gaussian2DKernel -from scopesim.utils import from_currsys, quantify, quantity_from_table, figure_factory, check_keys -from scopesim.base_classes import ImagePlaneBase, FieldOfViewBase -from scopesim.effects import PSF, PoorMansFOV - -from astropy.io.fits import HDUList -from matplotlib import pyplot as plt -from matplotlib.colors import LogNorm -import scopesim -from scopesim.utils import quantify -from scopesim import rc -from scopesim_templates.stellar import star_field, star_grid -from scopesim.optics.fov_manager import FOVManager - - - -print("Done with all the library installation") - -PLOTS = True - -class AnalyticalPSF(PSF): - """Base class for analytical PSFs.""" - - def __init__(self, **kwargs): - super().__init__(**kwargs) - self.meta["z_order"] = [41, 641] - self.convolution_classes = FieldOfViewBase - - -class NonCommonPathAberration(AnalyticalPSF): - """ - Non-Common Path Aberration class. - - Needed: pixel_scale - Accepted: kernel_width, strehl_drift - """ - - required_keys = {"pixel_scale"} - - def __init__(self, diameter, wave_min, wave_max, pixel_scale, **kwargs): - super().__init__(**kwargs) - self.meta["z_order"] = [241, 641] - self.meta["kernel_width"] = None - self.meta["strehl_drift"] = 0.02 - self.meta["wave_min"] = wave_min # Set the wave_min directly - self.meta["wave_max"] = wave_max # Set the wave_max directly - - self._total_wfe = None - self.valid_waverange = [wave_min * u.um, wave_max * u.um] - - self.convolution_classes = FieldOfViewBase - check_keys(self.meta, self.required_keys, action="error") - - def get_kernel(self, pixel_scale): - waves = (self.meta["wave_min"], self.meta["wave_max"]) - - old_waves = self.valid_waverange - wave_mid_old = 0.5 * (old_waves[0] + old_waves[1]) - wave_mid_new = 0.5 * (waves[0] + waves[1]) - strehl_old = wfe2strehl(wfe=self.total_wfe, wave=wave_mid_old) - strehl_new = wfe2strehl(wfe=self.total_wfe, wave=wave_mid_new) - - if np.abs(1 - strehl_old / strehl_new) > self.meta["strehl_drift"]: - self.valid_waverange = waves - self.kernel = wfe2gauss(wfe=self.total_wfe, wave=wave_mid_new, - width=self.meta["kernel_width"]) - self.kernel /= np.sum(self.kernel) - - return self.kernel - - def plot(self, pixel_scale): - """ - Plot the Vibration-affected PSF using Matplotlib. - - Parameters: - ----------- - pixel_scale : float - The pixel scale in arcseconds per pixel. - """ - kernel = self.get_kernel(pixel_scale) - - # Define axis values in arcseconds instead of pixels - size = kernel.shape[0] # Assuming the kernel is square - arcsec_extent = size * pixel_scale / 2 # Half the extent for centered plot - x = np.linspace(-arcsec_extent, arcsec_extent, size) - y = np.linspace(-arcsec_extent, arcsec_extent, size) - - plt.figure(figsize=(8, 6)) - plt.imshow(kernel, origin='lower', extent=[x[0], x[-1], y[0], y[-1]], cmap='plasma', norm=LogNorm(vmin=1e-6, vmax=1)) # Adjust vmin and vmax as necessary - plt.colorbar(label='Intensity') - plt.title(f"Non-Common Path Aberration PSF (Diameter = {diameter} m)") - plt.xlabel("X [arcseconds]") - plt.ylabel("Y [arcseconds]") - plt.gca().set_aspect('equal', adjustable='box') # Equal aspect ratio - plt.grid(False) # Optional: disable grid for clarity - plt.show() - -# Rest of your setup code... - -# Initialize the NonCommonPathAberration class -npc_psf = NonCommonPathAberration( - diameter=0.5, - wave_min=0.01161, - wave_max=0.01333, - pixel_scale=2.48 -) - -# Plot the Aberration affected PSF -npc_psf.plot(pixel_scale=2.48) - From c401e3bf0cf91b50ac2f2c40f4860bf21ac7bbd1 Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 23:15:03 +0200 Subject: [PATCH 42/43] Cleanup Vibration_psf --- DREAMS/Test_codes/Vibration_psf.py | 83 +++++++++++++++--------------- 1 file changed, 42 insertions(+), 41 deletions(-) diff --git a/DREAMS/Test_codes/Vibration_psf.py b/DREAMS/Test_codes/Vibration_psf.py index e4d38eb9..380ea6e0 100644 --- a/DREAMS/Test_codes/Vibration_psf.py +++ b/DREAMS/Test_codes/Vibration_psf.py @@ -1,27 +1,22 @@ -import os -import warnings import numpy as np -from astropy import units as u -from astropy.io.fits import HDUList +import pytest from matplotlib import pyplot as plt from matplotlib.colors import LogNorm import scopesim from astropy.convolution import Gaussian2DKernel -from scopesim.utils import quantify from scopesim import rc -from scopesim_templates.stellar import star_field, star_grid -from scopesim.optics.fov_manager import FOVManager +from scopesim_templates.stellar import star_field print("Done with all the library installation") - PLOTS = True # ---------------------------------------------------- # Define VibrationPSF for vibration-affected PSF # ---------------------------------------------------- + class VibrationPSF: """ Gaussian kernel for vibration-affected PSF. @@ -90,11 +85,11 @@ def plot(self, pixel_scale): # Define axis values in arcseconds instead of pixels size = kernel.shape[0] # Assuming the kernel is square arcsec_extent = size * pixel_scale / 2 # Half the extent for centered plot - x = np.linspace(-arcsec_extent, arcsec_extent, size) - y = np.linspace(-arcsec_extent, arcsec_extent, size) + extent = (-arcsec_extent, arcsec_extent, -arcsec_extent, arcsec_extent) plt.figure(figsize=(8, 6)) - plt.imshow(kernel, origin='lower', extent=[x[0], x[-1], y[0], y[-1]], cmap='plasma',norm=LogNorm(vmin=1e-6, vmax=1)) # Adjust vmin and vmax as necessary + # Adjust vmin and vmax as necessary + plt.imshow(kernel, origin='lower', extent=extent, cmap='plasma', norm=LogNorm(vmin=1e-6, vmax=1)) plt.colorbar(label='Intensity') plt.title(f"Vibration PSF (FWHM = {self.fwhm} arcsec, Axis = {self.vibration_axis})") plt.xlabel("X [arcseconds]") @@ -111,41 +106,47 @@ def plot(self, pixel_scale): if rc.__config__["!SIM.tests.run_integration_tests"] is False: pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") -# Initialize DREAMS optical train -dreams = scopesim.OpticalTrain("DREAMS") -assert isinstance(dreams, scopesim.OpticalTrain) -print("scopesim package loaded successfully.") -# Create a star field as the source -src = star_field(500, 10, 20, width=100) +def main(): + # Initialize DREAMS optical train + dreams = scopesim.OpticalTrain("DREAMS") + assert isinstance(dreams, scopesim.OpticalTrain) + print("scopesim package loaded successfully.") -# Set up user commands for the DREAMS simulation -cmds = scopesim.UserCommands(use_instrument="DREAMS") -cmds["!OBS.dit"] = 8 -cmds["!OBS.ndit"] = 1 -cmds["!DET.bin_size"] = 1 -cmds["!OBS.sky.bg_mag"] = 14.9 # J-band magnitude -cmds["!OBS.sky.filter_name"] = "J" -cmds["SIM.sub_pixel.flag"] = True + # Create a star field as the source + src = star_field(500, 10, 20, width=100) -# Reinitialize the optical train with the user commands -dreams = scopesim.OpticalTrain(cmds) -dreams["detector_linearity"].include = False + # Set up user commands for the DREAMS simulation + cmds = scopesim.UserCommands(use_instrument="DREAMS") + cmds["!OBS.dit"] = 8 + cmds["!OBS.ndit"] = 1 + cmds["!DET.bin_size"] = 1 + cmds["!OBS.sky.bg_mag"] = 14.9 # J-band magnitude + cmds["!OBS.sky.filter_name"] = "J" + cmds["SIM.sub_pixel.flag"] = True -# Perform observation -dreams.observe(src) -hdus = dreams.readout("vibration_analysis.fits") -print(f"Observation completed. HDUList type: {type(hdus[0])}") + # Reinitialize the optical train with the user commands + dreams = scopesim.OpticalTrain(cmds) + dreams["detector_linearity"].include = False -# ---------------------------------------------------- -# Apply the VibrationPSF to DREAMS Simulation Results -# ---------------------------------------------------- + # Perform observation + dreams.observe(src) + hdus = dreams.readout("vibration_analysis.fits") + print(f"Observation completed. HDUList type: {type(hdus[0])}") + + # ---------------------------------------------------- + # Apply the VibrationPSF to DREAMS Simulation Results + # ---------------------------------------------------- + + # Define the pixel scale for DREAMS + pixel_scale = 2.48 # Arcseconds per pixel for DREAMS + + # Instantiate the VibrationPSF class + vibration_psf = VibrationPSF(fwhm=5, amplitude=1.5, vibration_axis="x") # Elongation along the x-axis -# Define the pixel scale for DREAMS -pixel_scale = 2.48 # Arcseconds per pixel for DREAMS + # Plot the vibration-affected PSF + vibration_psf.plot(pixel_scale=pixel_scale) -# Instantiate the VibrationPSF class -vibration_psf = VibrationPSF(fwhm=5, amplitude=1.5, vibration_axis="x") # Elongation along the x-axis -# Plot the vibration-affected PSF -vibration_psf.plot(pixel_scale=pixel_scale) +if __name__ == '__main__': + main() From 96e79cda6ed2a6842bddbeacde0520b715301a76 Mon Sep 17 00:00:00 2001 From: Hugo Buddelmeijer Date: Wed, 15 Oct 2025 23:15:42 +0200 Subject: [PATCH 43/43] Delete PSF test files, not relevant for IRDB package --- DREAMS/Test_codes/Vibration_psf.py | 152 ----------------------------- DREAMS/Test_codes/seeing_psf.py | 102 ------------------- 2 files changed, 254 deletions(-) delete mode 100644 DREAMS/Test_codes/Vibration_psf.py delete mode 100644 DREAMS/Test_codes/seeing_psf.py diff --git a/DREAMS/Test_codes/Vibration_psf.py b/DREAMS/Test_codes/Vibration_psf.py deleted file mode 100644 index 380ea6e0..00000000 --- a/DREAMS/Test_codes/Vibration_psf.py +++ /dev/null @@ -1,152 +0,0 @@ -import numpy as np -import pytest -from matplotlib import pyplot as plt -from matplotlib.colors import LogNorm -import scopesim -from astropy.convolution import Gaussian2DKernel -from scopesim import rc -from scopesim_templates.stellar import star_field - -print("Done with all the library installation") - - -PLOTS = True - -# ---------------------------------------------------- -# Define VibrationPSF for vibration-affected PSF -# ---------------------------------------------------- - - -class VibrationPSF: - """ - Gaussian kernel for vibration-affected PSF. - Produces an elongated PSF along the vibration axis. - """ - - def __init__(self, fwhm=5.0, amplitude=1.5, vibration_axis="x"): - """ - Initialize the Vibration PSF for telescope vibrations. - - Parameters: - ----------- - fwhm : float - Full width at half maximum (FWHM) of the PSF in arcseconds. - amplitude : float - Amplitude of the vibration effect, controlling elongation of the PSF. - vibration_axis : str - Axis along which vibration occurs, either "x" or "y". - """ - self.fwhm = fwhm # FWHM in arcseconds - self.amplitude = amplitude # Vibration amplitude controlling the elongation - self.vibration_axis = vibration_axis # Vibration axis ("x" or "y") - - def get_kernel(self, pixel_scale): - """ - Calculate the vibration-affected Gaussian kernel. - - Parameters: - ----------- - pixel_scale : float - The pixel scale in arcseconds per pixel. - - Returns: - -------- - kernel : np.ndarray - The vibration-affected PSF kernel. - """ - # Convert FWHM to standard deviation (sigma) in pixels - sigma = self.fwhm / 2.35 / pixel_scale - - # Adjust sigma based on the vibration axis and amplitude - if self.vibration_axis == "x": - sigma_x = sigma * self.amplitude # Elongated along the x-axis - sigma_y = sigma # Normal along the y-axis - else: - sigma_x = sigma # Normal along the x-axis - sigma_y = sigma * self.amplitude # Elongated along the y-axis - - # Create a 2D Gaussian kernel with vibration effect - kernel = Gaussian2DKernel(x_stddev=sigma_x, y_stddev=sigma_y, mode="center").array - kernel /= np.sum(kernel) # Normalize the kernel to have unit sum - - return kernel - - def plot(self, pixel_scale): - """ - Plot the Vibration-affected PSF using Matplotlib. - - Parameters: - ----------- - pixel_scale : float - The pixel scale in arcseconds per pixel. - """ - kernel = self.get_kernel(pixel_scale) - - # Define axis values in arcseconds instead of pixels - size = kernel.shape[0] # Assuming the kernel is square - arcsec_extent = size * pixel_scale / 2 # Half the extent for centered plot - extent = (-arcsec_extent, arcsec_extent, -arcsec_extent, arcsec_extent) - - plt.figure(figsize=(8, 6)) - # Adjust vmin and vmax as necessary - plt.imshow(kernel, origin='lower', extent=extent, cmap='plasma', norm=LogNorm(vmin=1e-6, vmax=1)) - plt.colorbar(label='Intensity') - plt.title(f"Vibration PSF (FWHM = {self.fwhm} arcsec, Axis = {self.vibration_axis})") - plt.xlabel("X [arcseconds]") - plt.ylabel("Y [arcseconds]") - plt.gca().set_aspect('equal', adjustable='box') # Equal aspect ratio - plt.grid(False) # Optional: disable grid for clarity - plt.show() - - -# ---------------------------------------------------- -# DREAMS Simulation Setup -# ---------------------------------------------------- - -if rc.__config__["!SIM.tests.run_integration_tests"] is False: - pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") - - -def main(): - # Initialize DREAMS optical train - dreams = scopesim.OpticalTrain("DREAMS") - assert isinstance(dreams, scopesim.OpticalTrain) - print("scopesim package loaded successfully.") - - # Create a star field as the source - src = star_field(500, 10, 20, width=100) - - # Set up user commands for the DREAMS simulation - cmds = scopesim.UserCommands(use_instrument="DREAMS") - cmds["!OBS.dit"] = 8 - cmds["!OBS.ndit"] = 1 - cmds["!DET.bin_size"] = 1 - cmds["!OBS.sky.bg_mag"] = 14.9 # J-band magnitude - cmds["!OBS.sky.filter_name"] = "J" - cmds["SIM.sub_pixel.flag"] = True - - # Reinitialize the optical train with the user commands - dreams = scopesim.OpticalTrain(cmds) - dreams["detector_linearity"].include = False - - # Perform observation - dreams.observe(src) - hdus = dreams.readout("vibration_analysis.fits") - print(f"Observation completed. HDUList type: {type(hdus[0])}") - - # ---------------------------------------------------- - # Apply the VibrationPSF to DREAMS Simulation Results - # ---------------------------------------------------- - - # Define the pixel scale for DREAMS - pixel_scale = 2.48 # Arcseconds per pixel for DREAMS - - # Instantiate the VibrationPSF class - vibration_psf = VibrationPSF(fwhm=5, amplitude=1.5, vibration_axis="x") # Elongation along the x-axis - - # Plot the vibration-affected PSF - vibration_psf.plot(pixel_scale=pixel_scale) - - -if __name__ == '__main__': - main() diff --git a/DREAMS/Test_codes/seeing_psf.py b/DREAMS/Test_codes/seeing_psf.py deleted file mode 100644 index 16a2efca..00000000 --- a/DREAMS/Test_codes/seeing_psf.py +++ /dev/null @@ -1,102 +0,0 @@ -import os -import pytest -import numpy as np -from astropy.io.fits import HDUList -from matplotlib import pyplot as plt -from matplotlib.colors import LogNorm -import scopesim -from astropy.convolution import Gaussian2DKernel -from scopesim import rc -from scopesim_templates.stellar import star_field, star_grid -import scopesim_templates as sim_tp -from scopesim.optics.fov_manager import FOVManager -from astropy import units as u -from scopesim.utils import quantify - -PLOTS = True - -if rc.__config__["!SIM.tests.run_integration_tests"] is False: - pytestmark = pytest.mark.skip("Ignoring DREAMS integration tests") - -dreams = scopesim.OpticalTrain("DREAMS") -assert isinstance(dreams, scopesim.OpticalTrain) -print("scopesim package loaded successfully.") - -# Create a star field as the source -src = star_field(500, 10, 20, width=100) - -# Set up user commands for the DREAMS simulation -cmds = scopesim.UserCommands(use_instrument="DREAMS") -cmds["!OBS.dit"] = 8 -cmds["!OBS.ndit"] = 1 -cmds["!DET.bin_size"] = 1 -cmds["!OBS.sky.bg_mag"] = 14.9 # J-band magnitude -cmds["!OBS.sky.filter_name"] = "J" -cmds["SIM.sub_pixel.flag"] = True - -dreams = scopesim.OpticalTrain(cmds) -dreams["detector_linearity"].include = False - -# Perform observation -dreams.observe(src) -hdus = dreams.readout("uncrowded.fits") -print(f"Observation completed. HDUList type: {type(hdus[0])}") - -# ---------------------------------------------------- -# Define and Plot the SeeingPSF in Arcseconds -# ---------------------------------------------------- -class SeeingPSF: - """ - Gaussian kernel for seeing-limited PSF. - """ - - def __init__(self, fwhm=1.5): - self.fwhm = fwhm # FWHM in arcseconds - - def get_kernel(self, pixel_scale): - """ - Calculate Gaussian kernel for the given pixel scale and FWHM. - - Parameters: - ----------- - pixel_scale : float - The pixel scale in arcseconds/pixel. - - Returns: - -------- - kernel : np.ndarray - The Gaussian PSF kernel. - """ - sigma = self.fwhm / 2.35 / pixel_scale - kernel = Gaussian2DKernel(sigma, mode="center").array - kernel /= np.sum(kernel) # Normalize the kernel - return kernel - - def plot(self, pixel_scale): - """ - Plot the Seeing PSF in arcseconds using Matplotlib. - """ - kernel = self.get_kernel(pixel_scale) - - # Define axis values in arcseconds instead of pixels - size = kernel.shape[0] # Assuming the kernel is square - arcsec_extent = size * pixel_scale / 2 # Half the extent for centered plot - x = np.linspace(-arcsec_extent, arcsec_extent, size) - y = np.linspace(-arcsec_extent, arcsec_extent, size) - - plt.figure(figsize=(6, 6)) - plt.imshow(kernel, origin='lower', extent=[x[0], x[-1], y[0], y[-1]], cmap='plasma', norm=LogNorm()) - #plt.contour(x, y, kernel, colors='white', linewidths=0.5) # Add contours - - plt.colorbar(label='Intensity') - plt.title(f"Seeing PSF (FWHM = {self.fwhm} arcsec") - plt.xlabel("X [arcseconds]") - plt.ylabel("Y [arcseconds]") - plt.show() - -# Set the pixel scale and FWHM -pixel_scale = 2.48 # Pixel scale of 2.48 arcseconds per pixel -seeing_psf = SeeingPSF(fwhm=5) # Set FWHM to 5 arcseconds - -# Plot the SeeingPSF with arcseconds on the axes -seeing_psf.plot(pixel_scale=pixel_scale)