def get_ideal_photons(fields, cam, comps=True, plot=False): ntime, nwave = fields.shape[0], fields.shape[1] cam.rebinned_cube = np.zeros( (ntime, nwave, cam.array_size[1], cam.array_size[0])) for step in range(len(fields)): print(step) if comps: spectralcube = np.sum(fields[step], axis=1) else: spectralcube = fields[step, :, 0] cube = cam.get_ideal_cube(spectralcube) cam.rebinned_cube[step] = cube cam.rebinned_cube /= np.sum(cam.rebinned_cube) # /sp.numframes cam.rebinned_cube = np.transpose(cam.rebinned_cube, (1, 0, 2, 3)) if plot: # plt.figure() # plt.hist(cam.rebinned_cube[cam.rebinned_cube != 0].flatten(), bins=np.linspace(0, 1e4, 50)) # plt.yscale('log') grid(cam.rebinned_cube, show=True, title='get ideal photons', nstd=6) if cam.usesave: cam.save() return cam
def get_photons(self, datacube, chunk_step=0, plot=False): """ Given an intensity spectralcube and timestep create a quantized photon list :param datacube: :param step: :param plot: :return: """ if mp.QE_var: datacube *= self.QE_map.T num_events = self.num_from_cube(datacube) if sp.verbose: print( f"star flux: {ap.star_flux}, cube sum: {np.sum(datacube)}, numframes: {self.numframes}," f"num events: {num_events:e}") photons = self.sample_cube(datacube, num_events) photons[0] += chunk_step photons[0] = self.assign_time(photons[0]) photons[1] = self.assign_phase(photons[1]) if plot: grid(self.rebin_list(photons), title='get_photons') if sp.degrade_photons: photons = self.degrade_photons(photons) return photons
def make_fields_master(self, plot=False): """ The master fields file of which all the photons are seeded from according to their device :return: """ backup_fields = os.path.join(self.masterdir, 'fields_planet_slices.h5') ap.companion = False self.contrast = copy.deepcopy(ap.contrast) telescope = Telescope(usesave=False) fields = telescope()['fields'] unoccultname = os.path.join(iop.testdir, f'telescope_unoccult') self.psf_template = self.get_unoccult_psf(unoccultname) # grid(self.psf_template) if plot: grid(fields[0], logZ=True, title='make_fields_master') if os.path.exists(backup_fields): fields_master = fields else: assert len(fields.shape) == 6 collapse_comps = np.zeros( (sp.numframes, ap.n_wvl_final, sp.grid_size, sp.grid_size)) # grid(self.psf_template) for (x, y), scaling in zip( np.array(ap.companion_xy) * 20, self.contrast): cube = copy.deepcopy(self.psf_template) print(x, y, scaling) cube = np.roll(cube, -int(x), 2) cube = np.roll(cube, -int(y), 1) cube *= scaling # grid(cube) collapse_comps += cube obs_seq = np.abs(fields[:, -1])**2 fields_master = np.zeros( (sp.numframes, ap.n_wvl_final, 2, sp.grid_size, sp.grid_size)) # collapse_comps = np.sum(obs_seq[:, :, 1:], axis=2) fields_master[:, :, 0] = obs_seq[:, :, 0] fields_master[:, :, 1] = collapse_comps if plot: grid(fields_master[0], logZ=True, title='star and comps cube') dprint( f"Reduced shape of obs_seq = {np.shape(fields_master)} (numframes x nwsamp x 2 x grid x grid)" ) os.rename(iop.fields, backup_fields) telescope.save_fields(fields_master) return fields_master
def investigate_stats(): sp.grid_size = 512 sim = RunMedis(name=f'{TESTDIR}/fields', product='fields') observation = sim() fields = np.abs(observation['fields'][:,-1])**2 timecube = np.sum(fields[:,0], axis=1) grid([np.sum(timecube, axis=0)], show=False) locs = [[210,210], [256,256], [256,206], [256,512-206]] names = ['satelite', 'star', 'planet', 'speckle'] plot_stats(timecube, locs, names)
def view_reduced(): trios = [] for i in range(6, 21, 1): reduced_images = get_reduced_images(ind=-i, plot=False) PCA = reduced_images[1, 0] PCD = reduced_images[0, 2] PCDPCA = reduced_images[1, 2] trio = np.array([PCA, PCD, PCDPCA]) trio[trio <= 0] = 0.1 trios.append(trio) if i % 5 == 0: print(i) grid(trios, logZ=True, vlim=(1, 60), show=False) trios = [] plt.show(block=True)
def investigate_quantized(): sp.quick_detect = True mp.array_size = np.array([100, 100]) sp.verbose = True sp.save_to_disk = True center = mp.array_size[0] // 2 contrasts = range(-1, -8, -3) print(contrasts) locs = [[center + 33, center], [center, center], [center, center - 33], [center - 24, center + 24]] objects = ['satelite', 'star', 'planet', 'speckle'] # fig, axes = plt.subplots(2, len(contrasts)) name = f'{TESTDIR}/subaru/' axes_list = [] atmosdir = iop.atmosdir.split('/')[-1] iop.atmosdir = os.path.join(iop.datadir, name, iop.atmosroot, atmosdir) for c, contrast in enumerate(contrasts): axes_list.append(plt.subplots(2, len(locs))[1]) ap.contrast = 10**np.array([float(contrast)]) sim = RunMedis(name=name + f'1e{contrast}', product='photons') iop.atmosdir = os.path.join(iop.datadir, name, iop.atmosroot, atmosdir) iop.aberdir = os.path.join(iop.datadir, name, iop.aberroot, atmosdir) observation = sim() print(observation.keys(), observation['photons'].shape, observation['rebinned_photons'].shape) grid(observation['rebinned_photons'][:10], logZ=True, nstd=10, show=False, vlim=(0, 2)) timecube = np.sum(observation['rebinned_photons'], axis=1) # plot_stats(timecube, locs, names) for l, (loc, obj) in enumerate(zip(locs, objects)): print(l, loc, obj) bins_list, I_list, timesamps, lc_list = pixel_stats(timecube, loc) axes_list[c][0, l].plot(timesamps, lc_list[0]) axes_list[c][1, l].plot(bins_list[0][:-1], I_list[0]) axes_list[c][0, l].set_xlabel('time samples') axes_list[c][0, l].set_ylabel('intensity') axes_list[c][1, l].set_xlabel('intensity') axes_list[c][1, l].set_ylabel('amount') axes_list[c][0, l].set_title(f'{obj} contrast 10^{contrast}') plt.show()
def degrade_photons(self, photons, plot=False): if plot: grid(self.rebin_list(photons), title='before degrade') if mp.dark_counts: dark_photons = self.get_bad_packets(type='dark') dprint(photons.shape, dark_photons.shape, 'dark') photons = np.hstack((photons, dark_photons)) if mp.hot_pix: hot_photons = self.get_bad_packets(type='hot') photons = np.hstack((photons, hot_photons)) # stem = add_hot(stem) if plot: grid(self.rebin_list(photons), title='after bad') if mp.phase_uncertainty: photons[1] *= self.responsivity_error_map[np.int_(photons[2]), np.int_(photons[3])] photons, idx = self.apply_phase_offset_array(photons, self.sigs) # thresh = photons[1] < self.basesDeg[np.int_(photons[3]),np.int_(photons[2])] if mp.phase_background: thresh = -photons[1] > 3 * self.sigs[-1, np.int_(photons[3]), np.int_(photons[2])] photons = photons[:, thresh] if mp.remove_close: stem = self.arange_into_stem( photons.T, (self.array_size[0], self.array_size[1])) stem = self.remove_close(stem) photons = self.ungroup(stem) if plot: grid(self.rebin_list(photons), title='after remove close') # This step was taking a long time # stem = arange_into_stem(photons.T, (self.array_size[0], self.array_size[1])) # cube = make_datacube(stem, (self.array_size[0], self.array_size[1], ap.n_wvl_final)) # # ax7.imshow(cube[0], origin='lower', norm=LogNorm(), cmap='inferno', vmin=1) # cube /= self.QE_map # photons = ungroup(stem) return photons
def __call__(self, debug=True): dprint(self.performance_data) # self.performance_data = '/Users/dodkins/MKIDSim/mkid_param_invest/figure3_develop_mkid_lowerflux/1/max_count/performance_data.pkl' if not os.path.exists(self.performance_data): # self.metric.create_adapted_cams() comps_ = [True, False] pca_products = [] for comps in comps_: if hasattr(self.metric, 'get_rebinned_cubes'): self.metric.get_rebinned_cubes(self.master_fields, comps=comps) else: self.get_rebinned_cubes(self.master_fields, comps=comps) # pca_products.append(self.pca_rebinned_cubes(comps)) # # maps = pca_products[0] # rad_samps = pca_products[1][1] # thruputs = pca_products[1][2] # noises = pca_products[1][3] # conts = pca_products[1][4] maps, rad_samps, thruputs, noises, conts = self.pca_rebinned_cubes( ) with open(self.performance_data, 'wb') as handle: pickle.dump((maps, rad_samps, thruputs, noises, conts, self.metric.vals), handle, protocol=pickle.HIGHEST_PROTOCOL) else: with open(self.performance_data, 'rb') as handle: performance_data = pickle.load(handle) if len(performance_data) == 6: maps, rad_samps, thruputs, noises, conts, self.metric.vals = performance_data else: maps, rad_samps, conts, self.metric.vals = performance_data if debug: try: contrcurve_plot(self.metric.vals, rad_samps, thruputs, noises, conts) if self.metric.name != 'array_size': grid(maps, logZ=False, title=self.metric.name) #, vlim=(-2,2)) for no-normed else: pass plt.show(block=True) except UnboundLocalError: dprint('thruputs and noises not saved in old versions :(') # raise UnboundLocalError pass combo_performance(maps, rad_samps, conts, self.metric.vals, self.metric.name, [0, -1], savedir=self.testdir) return {'maps': maps, 'rad_samps': rad_samps, 'conts': conts}
tp.ao_act = 60 tp.rotate_atmos = False tp.rotate_sky = False tp.f_lens = 200.0 * tp.entrance_d tp.occult_loc = [0, 0] # Saving sp.save_to_disk = False # save obs_sequence (timestep, wavelength, x, y) sp.save_list = ['detector'] # list of locations in optics train to save # sp.skip_planes = ['coronagraph'] # ['wfs', 'deformable mirror'] # list of locations in optics train to save sp.quick_detect = True sp.debug = False sp.verbose = True if __name__ == '__main__': # ======================================================================= # Run it!!!!!!!!!!!!!!!!! # ======================================================================= sim = mm.RunMedis(name='general_example', product='photons') observation = sim() fp_sampling = sim.cam.platescale rebinned_photons = sim.cam.rebinned_cube dprint(f"Sampling in focal plane is {fp_sampling}") for o in range(len(ap.contrast) + 1): print(rebinned_photons.shape) datacube = rebinned_photons[o] print(o, datacube.shape) grid(datacube, logZ=True, title='Spectral Channels')
def get_form_photons(fields, cam, comps=True, plot=False, collapse_time_first=False, norm=False): """ Alternative to cam.__call__ that allows the user to specify whether the spectracube contains the planets :param fields: ndarray :param cam: mkids.Camera() :param comps: bool :return: mkids.Camera() """ dprint(cam.name) if os.path.exists(cam.name): print(f'loading cam rebined_cube save at {cam.name}') with open(cam.name, 'rb') as handle: cam = pickle.load(handle) else: if comps: fourcube = np.sum(fields, axis=2) else: fourcube = fields[:, :, 0] fourcube = np.abs(fourcube)**2 dprint(np.sum(fourcube)) fourcube = cam.rescale_cube(fourcube) max_steps = cam.max_chunk(fourcube) num_chunks = int(np.ceil(len(fourcube) / max_steps)) dprint(fourcube.shape, max_steps, len(fourcube) / max_steps, num_chunks) # cam.photons = np.empty((4,0)) cam.rebinned_cube = np.zeros_like(fourcube) for chunk in range(num_chunks): photons = cam.get_photons(fourcube[chunk * max_steps:(chunk + 1) * max_steps], chunk_step=chunk * max_steps) photons = cam.degrade_photons(photons) # cam.photons = np.hstack((cam.photons, photons)) # dprint(photons.shape, cam.photons.shape) cam.rebinned_cube[chunk * max_steps:(chunk + 1) * max_steps] = cam.rebin_list( photons, time_inds=[ chunk * max_steps, (chunk + 1) * max_steps ]) # cam.rebinned_cube = cam.rebin_list(cam.photons) cam.photons = None for step in range(len(fields)): print(step, cam.max_count) if cam.max_count: cam.rebinned_cube[step] = cam.cut_max_count( cam.rebinned_cube[step]) if norm: cam.rebinned_cube /= np.sum(cam.rebinned_cube) # /sp.numframes if collapse_time_first: grid(cam.rebinned_cube, title='comp sum', show=False, logZ=True) cam.rebinned_cube = np.median(cam.rebinned_cube, axis=0)[np.newaxis] grid(cam.rebinned_cube, title='comp sum', show=False, logZ=True) cam.rebinned_cube = np.transpose(cam.rebinned_cube, (1, 0, 2, 3)) if plot: grid(cam.rebinned_cube, show=True, title='get form photons') if cam.usesave: cam.save_instance() return cam
h5file.close() def load_fields(self, span=(0, -1)): """ load fields h5 warning sampling is not currently stored in h5. It is stored in telescope.pkl however """ print(f"Loading fields from {iop.fields}") h5file = tables.open_file(iop.fields, mode="r", title="MEDIS Electric Fields File") if span[1] == -1: self.cpx_sequence = h5file.root.data[span[0]:] else: self.cpx_sequence = h5file.root.data[span[0]:span[1]] h5file.close() self.pretty_sequence_shape() self.sampling = h5file.root.sampling[0] return {'fields': self.cpx_sequence, 'sampling': self.sampling} if __name__ == '__main__': iop.update_testname('telescope_module_test') telescope_sim = Telescope() observation = telescope_sim() print(observation.keys()) grid(observation['fields'], logZ=True, nstd=5)
self.platescale) ynew = np.arange(-self.array_size[1] * self.platescale / 2, self.array_size[1] * self.platescale / 2, self.platescale) mkid_cube = np.zeros((rebinned_cube.shape[0], rebinned_cube.shape[1], self.array_size[0], self.array_size[1])) for d, datacube in enumerate(rebinned_cube): for s, slice in enumerate(datacube): f = interpolate.interp2d(x, x, slice, kind='cubic') mkid_cube[d, s] = f(ynew, xnew) mkid_cube = mkid_cube * np.sum(datacube) / np.sum(mkid_cube) # grid(mkid_cube, logZ=True, show=True, extract_center=False, title='post') rebinned_cube = mkid_cube rebinned_cube[rebinned_cube < 0] *= -1 if conserve: rebinned_cube *= total / np.sum(rebinned_cube) return rebinned_cube if __name__ == '__main__': iop.update_testname('MKIDS_module_test') sp.quick_detect = True cam = Camera() observation = cam() print(observation.keys()) grid(observation['rebinned_photons'], nstd=5)
product = 'photons' # product = 'rebinned_cube' # product = 'fields' sp.verbose = True # sp.debug = True # sp.checkpointing = 10 if __name__ == '__main__': name = f'{TESTDIR}/{atmp.model}' sim = RunMedis(name=name, product=product) observation = sim() print(observation.keys(), ) if product == 'rebinned_cube': grid(observation['rebinned_cube'], vlim=(0, 3)) elif product == 'photons': grid(sim.cam.rebin_list(observation['photons']), vlim=(0, 3)) # plt.hist(observation['photons'][0]) # plt.show() else: dprint( np.sum( np.abs(np.sum(observation['fields'][:, -1, :, :], axis=2))**2)) grid(observation['fields']) if product == 'photons': from mkidpipeline.hdf.photontable import ObsFile # to look at the photontable obs = ObsFile(iop.photonlist)
def contrast_curve(): thrus = np.zeros((4, 5, 3)) # 4 conts, 5 rad, 3 types r = range(73) stds = np.zeros((1, len(r), 3)) fwhm = config['data']['fwhm'] planet_locs = np.array([[39, 36], [46, 44], [53, 51], [60, 59], [66, 65]]) loc_rads = np.sqrt(np.sum((mp.array_size[0] // 2 - planet_locs)**2, axis=1)) imlistsfile = 'imlists.npy' if os.path.exists(imlistsfile): with open(imlistsfile, 'rb') as f: imlists = np.load(f) else: imlists = [] alldata = load_meta(kind='pt_outputs') for ix, rev_ind in enumerate(range(1, 21, 1)): #1,21 cur_seg, pred_seg_res, cur_data, _, trainbool, _ = alldata[ -rev_ind] metrics = get_bin_measures(cur_seg, pred_seg_res, sum=False) true_star_photons = np.concatenate( (cur_data[metrics[1]], cur_data[metrics[3]]), axis=0) bins = [ np.linspace(true_star_photons[:, 0].min(), true_star_photons[:, 0].max(), sp.numframes + 1), np.linspace(true_star_photons[:, 1].min(), true_star_photons[:, 1].max(), ap.n_wvl_final + 1), np.linspace(-200, 200, 151), np.linspace(-200, 200, 151) ] true_star_tess, edges = np.histogramdd(true_star_photons, bins=bins) true_star_tess = np.transpose(true_star_tess, axes=(1, 0, 2, 3)) angle_list = -np.linspace( 0, sp.numframes * sp.sample_time * config['data']['rot_rate'] / 60, true_star_tess.shape[1]) star_derot = np.sum(cube_derotate(np.sum(true_star_tess, axis=0), angle_list, imlib='opencv', interpolation='lanczos4'), axis=0) reduced_images = get_reduced_images(ind=-rev_ind, plot=False) PCA = reduced_images[1, 0] PCD = reduced_images[0, 2] PCDPCA = reduced_images[1, 2] imlist = np.array([star_derot, PCA, PCD, PCDPCA]) # imlist[imlist <= 0] = 0.01 imlists.append(imlist) with open(imlistsfile, 'wb') as f: np.save(f, np.array(imlists)) trios = [] for ix in range(20): imlist = imlists[ix] star_derot, PCA, PCD, PCDPCA = imlist cont_ind = ix // 5 r_ind = ix % 5 trio = np.array([PCA, PCD, PCDPCA]) trio[trio <= 0] = 0.1 trios.append(trio) if ix % 5 == 4: print(ix) grid(trios, logZ=True, vlim=(1, 60), show=False) trios = [] plot = False # if cont_ind >= 0: # plot = True # true_flux = aperture_flux(planet_derot, [planet_locs[r_ind,0]],[planet_locs[r_ind,1]], fwhm, plot=plot)[0] # measured = np.array([aperture_flux(PCA, [planet_locs[r_ind,0]],[planet_locs[r_ind,1]], fwhm, plot=plot)[0], # aperture_flux(PCD, [planet_locs[r_ind,0]], [planet_locs[r_ind,1]], fwhm, plot=plot)[0], # aperture_flux(PCDPCA, [planet_locs[r_ind,0]], [planet_locs[r_ind,1]], fwhm, plot=plot)[0] # ]) # print(ix, cont_ind, r_ind, measured/true_flux, true_flux) # thrus[cont_ind, r_ind] = measured/true_flux if cont_ind == 0: #4-1: std = np.array([ noise_per_annulus(PCA, 1, fwhm)[0], noise_per_annulus(PCD, 1, fwhm)[0], noise_per_annulus(PCDPCA, 1, fwhm)[0] ]) stds[0] = std.T plt.show() # mean_thrus = np.mean(thrus[2:], axis=0) full_thru = noise_per_annulus(star_derot, 1, fwhm, mean_per_ann=True)[0] # full_thrus = [] fig = plt.figure() ax1 = fig.add_subplot(1, 3, 1) ax2 = fig.add_subplot(1, 3, 2) ax3 = fig.add_subplot(1, 3, 3) labels = ['PCA', 'PCD (sum)', 'PCD + PCA'] for i in range(3): # ax1.plot(loc_rads[::-1], mean_thrus[:,i][::-1], 'o') # f = InterpolatedUnivariateSpline(loc_rads[::-1], mean_thrus[:,i][::-1], k=1, ext=3) # switch order since furthest out is first # full_thru = f(r) # full_thru[full_thru<=0] = 0.01 sensitivity = stds[0, :, i] / max(full_thru) ax1.plot(full_thru) ax2.plot(stds[0, :, i]) ax3.plot(sensitivity) ax1.set_yscale("log") ax2.set_yscale("log") ax3.set_yscale("log") # plt.plot(sensitivity/1e5, label=labels[i]) # plt.yscale("log") # plt.legend() plt.show(block=True)
def pca_rebinned_cubes(self): maps, rad_samps, thruputs, noises, conts = [], [], [], [], [] cams = self.metric.cams colors = [f'C{i}' for i in range(len(self.metric.cams['star']))] # fig, axes = plt.subplots(1,6) fig, axes = plt.subplots(1, 3) dprint(np.shape(axes)) for i in range(len(cams['comp'])): comp_cube = cams['comp'][i].rebinned_cube dprint(comp_cube.shape) frame_comp = pca.pca(comp_cube, angle_list=np.zeros((comp_cube.shape[1])), scale_list=self.scale_list, mask_center_px=None, adimsdi='double', ncomp=self.ncomp, ncomp2=None, collapse=self.collapse) maps.append(frame_comp) nocomp_cube = cams['star'][i].rebinned_cube frame_nocomp = pca.pca(nocomp_cube, angle_list=np.zeros((nocomp_cube.shape[1])), scale_list=self.scale_list, mask_center_px=None, adimsdi='double', ncomp=self.ncomp, ncomp2=None, collapse=self.collapse) median_fwhm = cams['star'][i].lod if hasattr( cams['star'][i], 'lod') else mp.lod median_wave = (self.wsamples[-1] + self.wsamples[0]) / 2 fwhm = median_fwhm * self.wsamples / median_wave mask = cams['star'][i].QE_map == 0 print('check whether to be using mask here?!') noise_samp, rad_samp = contrcurve.noise_per_annulus( frame_nocomp, separation=1, fwhm=median_fwhm) # mask=mask) xy = np.array( ap.companion_xy ) * 20 * cams['star'][i].sampling / cams['star'][i].platescale px, py = (cams['star'][i].array_size[::-1] / 2 - xy).T cx, cy = cams['star'][i].array_size[::-1] / 2 dists = np.sqrt((py - cy)**2 + (px - cx)**2) # grid(np.sum(comp_cube, axis=1), title='in comp time collapse', show=False) # injected_flux=[contrcurve.aperture_flux(np.sum(comp_cube-nocomp_cube, axis=1)[i], py, px, fwhm[i]/1.5, ap_factor=1) for i in range(comp_cube.shape[0])] injected_flux = [ contrcurve.aperture_flux(np.sum(comp_cube, axis=1)[i], py, px, fwhm[i] / 1.5, ap_factor=1, plot=False) for i in range(comp_cube.shape[0]) ] # [axes[i+3].plot(dists, influx_wave) for influx_wave in injected_flux] injected_flux = np.mean(injected_flux, axis=0) # if i ==0 or i == len(self.metric.cams['star'])-1: # grid(comp_cube, title='comp', show=False) # grid(nocomp_cube, title='no', show=False) # grid(comp_cube-nocomp_cube, title='diff', show=False) # grid([np.sum(comp_cube, axis=(0,1))], title='sum comp', logZ=True, show=False) # grid([np.sum(nocomp_cube, axis=(0,1))], title='sum nocomp', logZ=True, show=False) # grid([np.sum(comp_cube, axis=(0,1))-np.sum(nocomp_cube, axis=(0,1))], title='sum then diff', logZ=True, show=False) # grid([], title='comp', logZ=True, show=False) grid([frame_comp, frame_nocomp, frame_comp - frame_nocomp], title='comp, nocomp, diff', logZ=False, show=False, vlim=(-2e-7, 2e-7)) # vlim=(-2,2))#, vlim=(-2e-7,2e-7)) grid([ np.sum(comp_cube, axis=1)[::4], np.sum(nocomp_cube, axis=1)[::4] ], title='input: comp, no comp', logZ=False, show=False, vlim=(-1e-5, 1e-5)) # vlim=(-2,2))#, vlim=(-1e-5,1e-5)) grid(np.sum(comp_cube - nocomp_cube, axis=1)[::4], title='diiff input cube', logZ=False, show=False) #, vlim=(-2,2)) # grid([(frame_comp-frame_nocomp)/(np.sum(comp_cube-nocomp_cube, axis=(0,1)))], title='throughput', logZ=True, show=False) # recovered_flux = contrcurve.aperture_flux((frame_comp - frame_nocomp), py, px, median_fwhm/1.5, ap_factor=1, ) recovered_flux = contrcurve.aperture_flux((frame_comp), py, px, median_fwhm / 1.5, ap_factor=1, plot=False) # thruput = recovered_flux*1e6 #/ injected_flux thruput = recovered_flux / injected_flux thruput[np.where(thruput < 0)] = 0 # plt.figure() axes[0].plot(dists, thruput, c=colors[i]) axes[1].plot(dists, injected_flux, c=colors[i]) axes[2].plot(dists, recovered_flux, c=colors[i], label=f'{self.metric.vals[i]}') axes[2].legend() # plt.plot(rad_samp, noise_samp) # plt.show() win = min(noise_samp.shape[0] - 2, int(2 * median_fwhm)) if win % 2 == 0: win += 1 noise_samp_sm = savgol_filter(noise_samp, polyorder=2, mode='nearest', window_length=win) # thruput_mean_log = np.log10(thruput + 1e-5) # f = InterpolatedUnivariateSpline(dists, thruput_mean_log, k=2) # thruput_interp_log = f(rad_samp) # thruput_interp = 10 ** thruput_interp_log # thruput_interp[thruput_interp <= 0] = np.nan # 1e-5 # thruput_interp = np.interp(rad_samp, dists, thruput) from scipy.interpolate import interp1d # f = interp1d(dists, thruput, fill_value='extrapolate') # thruput_interp = f(rad_samp) thruput_com = thruput.reshape(4, -1, order='F').mean(axis=0) dists_com = dists.reshape(4, -1, order='F').mean(axis=0) thruput_com_log = np.log10(thruput_com + 1e-5) f = interp1d(dists_com, thruput_com_log, fill_value='extrapolate') thruput_interp_log = f(rad_samp) thruput_interp = 10**thruput_interp_log axes[0].plot(dists_com, thruput_com, marker='o', c=colors[i]) print(thruput, thruput_interp) axes[0].plot(rad_samp, thruput_interp, c=colors[i]) starphot = 1.1 / 2 sigma = 5 cont_curve_samp = ( (sigma * noise_samp_sm) / thruput_interp) / starphot cont_curve_samp[cont_curve_samp < 0] = 1 cont_curve_samp[cont_curve_samp > 1] = 1 thruputs.append(thruput_interp) noises.append(noise_samp_sm) conts.append(cont_curve_samp) rad_samp = cams['star'][i].platescale * rad_samp rad_samps.append(rad_samp) # maps.append(frame_nocomp) plt.show(block=True) return maps, rad_samps, thruputs, noises, conts
class vel(): def __init__(self, num_samp=3): self.median_val = 10 # self.multiplier = np.logspace(np.log10(0.1), np.log10(10), num_samp) self.multiplier = np.array([0]) self.vals = self.multiplier * self.median_val if __name__ == '__main__': metric_config = vel() for i, val in enumerate(metric_config.vals): atmp.vel = val name = f'{TESTDIR}/{val}' sim = RunMedis(name=name, product=product) observation = sim() if product == 'fields': grid(observation['fields'], show=False)#, vlim=(-2e-7,2e-7)) elif product == 'photons': grid(sim.cam.rebin_list(observation['photons']), show=False) # to look at the photontable obs = ObsFile(iop.photonlist) print(obs.photonTable) # to plot an image of all the photons on the array image = obs.getPixelCountImage(integrationTime=None)['image'] quick2D(image, show=False, title=f'{val}') plt.show(block=True)
planet_photons = np.array(planet_photons).T.astype(np.float32) planet_photons = np.insert(planet_photons, obj=1, values=cam.phase_cal(ap.wvl_range[0]), axis=0) planet_photons[0] = (planet_photons[0] + abs_step) * sp.sample_time photons = np.concatenate((star_photons, planet_photons), axis=1) # cam.save_photontable(photonlist=photons, index=None, populate_subsidiaries=False) stem = cam.arange_into_stem(photons.T, (cam.array_size[1], cam.array_size[0])) stem = list(map(list, zip(*stem))) stem = cam.remove_close(stem) photons = cam.ungroup(stem) photons = photons[[0, 1, 3, 2]] # grid(cam.rebin_list(photons), show=False) cam.populate_photontable(photons=photons, finalise=False) cam.populate_photontable(photons=[], finalise=True) grid(cam.rebin_list(photons), show=False) # to look at the photontable obs = Photontable(iop.photonlist) print(obs.photonTable) # to plot an image of all the photons on the array image = obs.getPixelCountImage(integrationTime=None)['image'] quick2D(image, show=False, title='Const planet photons') plt.show(block=True)
def get_reduced_images(ind=1, use_spec=True, plot=False, use_pca=True, verbose=False): """ Looks for reduced images file in the home folder and returns if it exists. If you're on the local machine and the file has not been transferred it will throw a FileNotFoundError """ all_photons, star_photons, planet_photons = get_photons(amount=-ind) all_tess, star_tess, planet_tess = ( get_tess(photons) for photons in [all_photons, star_photons, planet_photons]) all_tess = np.transpose(all_tess, axes=(1, 0, 2, 3)) star_tess = np.transpose(star_tess, axes=(1, 0, 2, 3)) planet_tess = np.transpose(planet_tess, axes=(1, 0, 2, 3)) all_raw = np.sum(all_tess, axis=(0, 1)) star_raw = np.sum(star_tess, axis=(0, 1)) planet_raw = np.sum(planet_tess, axis=(0, 1)) sp.numframes = 80 sp.sample_time = 15 angle_list = -np.linspace( 0, sp.numframes * sp.sample_time * config['data']['rot_rate'] / 60, all_tess.shape[1]) print(angle_list, 'angle') if use_spec: wsamples = np.linspace(ap.wvl_range[0], ap.wvl_range[1], all_tess.shape[0]) scale_list = wsamples / (ap.wvl_range[1] - ap.wvl_range[0]) all_pca = pca.pca(all_tess, angle_list=angle_list, scale_list=scale_list, mask_center_px=None, adimsdi='double', ncomp=(None, 1), collapse='sum', verbose=verbose) star_pca = pca.pca(star_tess, angle_list=angle_list, scale_list=scale_list, mask_center_px=None, adimsdi='double', ncomp=(None, 1), collapse='sum', verbose=verbose) planet_pca = pca.pca(planet_tess, angle_list=angle_list, scale_list=scale_list, mask_center_px=None, adimsdi='double', ncomp=(None, 1), collapse='sum', verbose=verbose) # reduced_images = np.array([[all_raw, star_raw, planet_raw], [all_pca, star_pca, planet_pca]]) all_med = medsub_source.median_sub(all_tess, angle_list=angle_list, scale_list=scale_list, collapse='sum') star_med = medsub_source.median_sub(star_tess, angle_list=angle_list, scale_list=scale_list, collapse='sum') planet_med = medsub_source.median_sub(planet_tess, angle_list=angle_list, scale_list=scale_list, collapse='sum') else: pass # all_med = medsub_source.median_sub(np.sum(all_tess, axis=0), angle_list=angle_list, collapse='sum') # star_med = medsub_source.median_sub(np.sum(star_tess, axis=0), angle_list=angle_list, collapse='sum') # planet_med = medsub_source.median_sub(np.sum(planet_tess, axis=0), angle_list=angle_list, # collapse='sum') all_derot = np.sum(cube_derotate(np.sum(all_tess, axis=0), angle_list, imlib='opencv', interpolation='lanczos4'), axis=0) star_derot = np.sum(cube_derotate(np.sum(star_tess, axis=0), angle_list, imlib='opencv', interpolation='lanczos4'), axis=0) planet_derot = np.sum(cube_derotate(np.sum(planet_tess, axis=0), angle_list, imlib='opencv', interpolation='lanczos4'), axis=0) # all_snr = snrmap(all_pca, fwhm=5, plot=True) # star_snr = snrmap(star_pca, fwhm=5, plot=True) # planet_snr = snrmap(planet_pca, fwhm=5, plot=True) reduced_images = np.array([[all_raw, star_raw, planet_raw], [all_derot, star_derot, planet_derot], [all_pca, star_pca, planet_pca], [all_med, star_med, planet_med] ]) #, ) # [all_snr, star_snr, planet_snr] planet_loc = (92, 60) fwhm = config['data']['fwhm'] nproc = 8 # reduced_images = np.array([[all_med, snrmap(all_med, fwhm, known_sources=planet_loc, nproc=nproc)], # [all_pca, snrmap(all_pca, fwhm, known_sources=planet_loc, nproc=nproc)], # [planet_derot, snrmap(planet_derot, fwhm, known_sources=planet_loc, nproc=nproc)], # [planet_pca, snrmap(planet_pca, fwhm, known_sources=planet_loc, nproc=nproc)]]) # plt.imshow(planet_derot) # plt.imshow(snrmap(planet_derot, fwhm, nproc=nproc)) # plt.show() # reduced_images = np.array([[all_raw, star_raw, planet_raw]]) # grid(reduced_images, logZ=True, vlim=(1,50)) #, vlim=(1,70) if plot: grid(reduced_images, vlim=(-10, 106)) return reduced_images