def run_model_grid(target_spec,target_err=None): mask_list= [lyman_alpha]+[oxygen]+[seg_gap]+[nitrogen] target_spec = spt.clean_spectrum(target_spec, min_wave, max_wave, mask_list) target_err = spt.clean_spectrum(target_err, min_wave, max_wave, mask_list) model_file_list = glob(model_path+'*'+model_extension) dist_list = [] for model_file in model_file_list: model_spec = get_model_fromfile(model_file) #model_spec= spt.trim_spec(model_spec, np.min(target_spec[0]), np.max(target_spec[0])) model_spec= spt.clean_spectrum(model_spec, min_wave, max_wave, mask_list) scaling_coefficient= get_scale_factor(target_spec, model_spec, scale_wave_range) model_spec[1]=model_spec[1]*scaling_coefficient new_dist = calc_sq_dist(target_spec, model_spec, error_spec = target_err) dist_list.append(new_dist) teff_array, logg_array = make_model_params_arrays(model_file_list) dist_array = np.array(dist_list) for mod_file, dist_mod in zip(model_file_list, dist_list): print("model_file:", mod_file, "difference:", dist_mod) min_index = np.argmin(dist_list) min_model = model_file_list[min_index] min_dist = dist_array[min_index] print("best fit model:", min_model) model_spec= get_model_fromfile(min_model) #model_spec = spt.trim_spec(model_spec, np.min(target_spec[0]), np.max(target_spec[0])) model_spec= spt.clean_spectrum(model_spec, np.min(target_spec[0]), np.max(target_spec[0]), mask_list) scaling_coefficient= get_scale_factor(target_spec, model_spec, scale_wave_range) model_spec[1]= model_spec[1]*scaling_coefficient calc_rdist(scaling_coefficient) plot_overlays(target_spec, model_spec, target_err) chi_square_countours(teff_array,logg_array, dist_array)
def retrieve_target_spec(target_name): """ Input: -target_name : the directory name of the target in HST_COS. It should exclude the slash """ target_path = target_name+'/' target_x1ds= glob(target_path+'*x1dsum.fits') target_file= target_x1ds[-1] #I only want the first one for now; when I eventually make this include all the visits for a given target I'll introduce some sort of function for combining them or whatever target_hdu= fits.open(target_file) cenwave=target_hdu[0].header['CENWAVE'] grating = target_hdu[0].header['OPT_ELEM'] seg_gap = config.seg_gap_dict[str(grating)][str(cenwave)] lyman_alpha = config.lyman_mask oxygen= config.oxygen_mask nitrogen = config.nitrogen_mask print("grating (OPT_ELEM):", grating, "Centwave: ", target_hdu[0].header['CENWAVE']) #exposure_time = target_hdu[0].header['EXPTIME'] target_waves = np.copy(target_hdu[1].data['wavelength'].ravel()) target_flux= np.copy(target_hdu[1].data['flux'].ravel()) target_error = np.copy(target_hdu[1].data['ERROR'].ravel()) target_spec= np.vstack([target_waves, target_flux]) target_err = np.vstack([target_waves, target_error]) mask_list= [lyman_alpha]+[oxygen]+[seg_gap]+[nitrogen] target_spec = spt.clean_spectrum(target_spec, min_wave, max_wave, mask_list) target_err = spt.clean_spectrum(target_err, min_wave, max_wave, mask_list) return target_spec, target_err
def plot_all_x1d(target_dir, low_lim, high_lim, log_scale): wave_min = low_lim #lyman = [1208, 1225] #oxygen= [1295, 1312] #airglow wavelengths to be filtered according to lightcurve wave_max = high_lim #lcbase= target_dir+ '_grid_lightcurves/' + '*step' + str(stepsize) + '_*'+str(wave_min)+',' + str(wave_max)+'*' #lcfile= glob(lcbase)[0] #dest_dir = 'dual_plots/' #if not os.path.exists(dest_dir): #os.makedirs(dest_dir) for dataset in glob(target_dir + '/*x1d.fits'): hdu = fits.open(dataset) try: print(dataset, hdu[0].header['OPT_ELEM'], hdu[0].header['CENWAVE'], hdu[1].header['EXPTIME'], "LP-POS: ", hdu[0].header['LIFE_ADJ'], "FP-POS: ", hdu[0].header['FPPOS']) except KeyError as error: print('KeyError:', error) print('filename that produced error:', dataset) print(dataset, hdu[0].header['OPT_ELEM'], hdu[0].header['CENWAVE'], hdu[1].header['EXPTIME'], "LP-POS: ", "FP-POS: ", hdu[0].header['FPPOS']) fig = plt.figure(figsize=(200, 9)) #silicon_lines= [1190, 1193, 1195, 1197, 1207, 1260, 1265, 1304, 1309] ax1 = fig.add_subplot(1, 1, 1) counter = 0 for dataset in glob(target_dir + '/*x1d.fits'): hdu = fits.open(dataset) #print(hdu[1]) #print(hdu[1]['FUVA']) #print(hdu[1].data[0]) #print(hdu[1].data.shape) #for thing in hdu[1].data: #print("thing: ", thing) #print(thing['wavelength']) fppos = hdu[0].header['FPPOS'] fppos_color = fp_pos_colors[fppos] wavelengths = np.copy(hdu[1].data['wavelength'].ravel()) print(wavelengths.shape) fluxes = np.copy(hdu[1].data['flux'].ravel()) #fluxes= np.copy(hdu[1].data['Gcounts'].ravel()) #print("fluxes", fluxes) arrshape = wavelengths.shape target_spec = np.vstack([wavelengths, fluxes]) mask_list = [config.lyman_mask] + [config.oxygen_mask] + [ config.nitrogen_mask ] #need to add the segment gap (not implemented directly in spec_plot_tools because it will eventually be called from a dict based on grating and central wavelength cleaned_spec = spt.clean_spectrum(target_spec, wave_min, wave_max, mask_list) fluxes = cleaned_spec[1] wavelengths = cleaned_spec[0] #print("fluxes.shape: ", fluxes.shape) #print("wavelengths.shape" , wavelengths.shape) if counter == 0: flux_all = np.array([np.zeros(fluxes.shape)]) print("flux_all.shape: ", flux_all.shape) plot_waves = wavelengths try: flux_all = np.append(flux_all, [fluxes], axis=0) print(flux_all.shape) except ValueError as error: print(error) shape_dif = flux_all.shape[1] - fluxes.shape[0] if shape_dif > 0: padarray = np.zeros(shape_dif) fluxes_pad = np.append(fluxes, padarray) flux_all = np.append(flux_all, [fluxes_pad], axis=0) elif shape_dif < 0: flux_all = np.append(flux_all, [fluxes[:shape_dif]], axis=0) print("truncating new spectrum to mach previous dimensions") counter += 1 #print("sum fluxes: ", np.sum(fluxes)) ax1.plot(wavelengths, fluxes, label=hdu[1].header['EXPSTART'], color=fppos_color) for this_line in config.silicon_lines: if ((this_line >= wave_min) & (this_line <= wave_max)): ax1.axvline(x=this_line, linestyle='-', color='g', ymin=0, ymax=100000, linewidth=1, alpha=0.2) print(flux_all.shape) flux_all = flux_all[1:, :] #remove the first row of zeros flux_med = np.nanmedian(flux_all, axis=0) #flux_med= np.sum(flux_all, axis=0) ax1.plot(plot_waves, flux_med, label='median combined spectra', color=fp_pos_colors[0]) ax1.legend(numpoints=1, fontsize=14, loc='best') ax1.set_ylabel('Flux (cgs)') ax1.set_xlabel('Wavelength $(\AA)$') ax1.set_title(target_dir) if log_scale: ax1.set_yscale('log') #bad_inds = np.where( #fig.tight_layout() fig.savefig(target_dir + 'x1dtruesum.pdf') plt.show()
def make_dual_plots(target_dir, stepsize, wave_limits=[1130, 1900]): wave_min = wave_limits[0] #lyman = [1208, 1225] #oxygen= [1295, 1312] #airglow wavelengths to be filtered according to lightcurve wave_max = wave_limits[1] lcbase = target_dir + '_grid_lightcurves/' + '*step' + str( stepsize) + '_*' + str(wave_min) + ',' + str(wave_max) + '*' lcfile = glob(lcbase)[0] dest_dir = 'dual_plots/' + target_dir + "/" if not os.path.exists(dest_dir): os.makedirs(dest_dir) for dataset in glob(target_dir + '/*x1dsum.fits'): hdu = fits.open(dataset) print(dataset, hdu[0].header['OPT_ELEM'], hdu[0].header['CENWAVE'], hdu[1].header['EXPTIME']) #moved 2019-07-15 #fig = plt.figure(figsize=(20,9)) ##silicon_lines= [1190, 1193, 1195, 1197, 1207, 1260, 1265, 1304, 1309] #ax1 = fig.add_subplot(2,1,1) counter = 0 #get the mask degree used for the light curve to produce the overhead spectrum with open(lcfile, 'rb') as csvfile: reader = csv.reader(csvfile, delimiter=',') for row in reader: print('reading row') row = row[0] mask_deg = int(row.split('=')[1]) print('mask_deg:', mask_deg) break #mask_deg= 1 for dataset in glob(target_dir + '/*x1dsum.fits'): hdu = fits.open(dataset) cenwave = str(hdu[0].header['CENWAVE']) grating = str(hdu[0].header['OPT_ELEM']) try: seg_gap = config.seg_gap_dict[str(grating)][str(cenwave)] except KeyError as error: print(error) print("No segment gap mask for OPT_ELEM " + grating + ' at ' + cenwave + ' A') seg_gap = [wave_max, wave_min] #print(hdu[1]) #print(hdu[1]['FUVA']) #print(hdu[1].data[0]) #print(hdu[1].data.shape) #for thing in hdu[1].data: #print("thing: ", thing) #print(thing['wavelength']) wavelengths = np.copy(hdu[1].data['wavelength'].ravel()) print(wavelengths.shape) fluxes = np.copy(hdu[1].data['flux'].ravel()) #print("fluxes", fluxes) arrshape = wavelengths.shape target_spec = np.vstack([wavelengths, fluxes]) mask_list = [config.lyman_mask_list[mask_deg]] + [ config.oxygen_mask_list[mask_deg] ] + [config.nitrogen_mask_list[mask_deg]] + [seg_gap] #mask_list= [config.lyman_mask]+[config.oxygen_mask]+[config.nitrogen_mask] +[seg_gap] cleaned_spec = spt.clean_spectrum(target_spec, wave_min, wave_max, mask_list) wavelengths = cleaned_spec[0] fluxes = cleaned_spec[1] print("fluxes.shape: ", fluxes.shape) print("wavelengths.shape", wavelengths.shape) if counter == 0: flux_all = np.array([np.zeros(fluxes.shape)]) print("flux_all.shape: ", flux_all.shape) plot_waves = wavelengths try: flux_all = np.append(flux_all, [fluxes], axis=0) print(flux_all.shape) except ValueError as error: print(error) shape_dif = flux_all.shape[1] - fluxes.shape[0] if shape_dif > 0: padarray = np.zeros(shape_dif) fluxes_pad = np.append(fluxes, padarray) flux_all = np.append(flux_all, [fluxes_pad], axis=0) elif shape_dif < 0: flux_all = np.append(flux_all, [fluxes[:shape_dif]], axis=0) print("truncating new spectrum to mach previous dimensions") counter += 1 #print("sum fluxes: ", np.sum(fluxes)) #ax1.plot(wavelengths, fluxes/np.nanmean(fluxes), label=hdu[0].header['rootname']) #for this_line in config.silicon_lines: #ax1.axvline(x= this_line ,linestyle = '-', color = 'g' , ymin = 0, ymax = 100000, linewidth = 1, alpha = 0.2) try: #moved here 2019-07-15 fig = plt.figure(figsize=(20, 9)) #silicon_lines= [1190, 1193, 1195, 1197, 1207, 1260, 1265, 1304, 1309] ax1 = fig.add_subplot(2, 1, 1) ########################## for this_line in config.silicon_lines: if ((this_line >= wave_min) & (this_line <= wave_max)): ax1.axvline(x=this_line, linestyle='-', color='g', ymin=0, ymax=100000, linewidth=1, alpha=0.2) print(flux_all.shape) flux_all = flux_all[1:, :] #remove the first row of zeros flux_med = np.nanmedian(flux_all, axis=0) #ax1.plot(plot_waves, flux_med/np.nanmean(flux_med), label= 'median combined averaged spectra') ax1.plot(plot_waves, flux_med, label='median combined averaged spectra') ax1.legend(numpoints=1, fontsize=14, loc='best') #ax1.set_ylabel('Flux (normed)') ax1.set_ylabel('Flux (cgs units)') ax1.set_xlabel('Wavelength $(\AA)$') ax1.set_title(target_dir) #ax1.set_yscale('log') ax2 = fig.add_subplot(2, 1, 2) second_per_mjd = 1. / 1.15741e-5 #SECOND_PER_MJD value from lightcurve.cos.extract, but I couldn't import it for whatever reason... so I just copied and pasted #if unit_arg.startswith('s'): #print("period in seconds") #time_converter = second_per_mjd #time_string = 's' #elif unit_arg.startswith('h'): #print("period in hours") #time_converter= second_per_mjd/3600. #time_string = 'hrs' #elif unit_arg.startswith('d'): #print('period in days') #time_converter = 1. #time_string = 'days' #elif unit_arg.startswith('m'): #print('period in minutes') #time_converter = second_per_mjd/60. #time_string = 'min' #all_array = np.genfromtxt(lcfile, names=True) try: all_array = np.genfromtxt(lcfile, names=True, skip_header=1) #times= Time(all_array['mjd'], format='mjd') #times= np.copy(all_array['mjd']) times = Time(all_array['bmjd_tdb'], format='mjd', scale='tdb').mjd except ValueError as error: print("ValueError:", error) print( "probably due to this lightcurve being before the addition of comments,\nso now we won't skip any lines." ) all_array = np.genfromtxt(lcfile, names=True) times = Time(all_array['bmjd_tdb'], format='mjd', scale='tdb').mjd fluxes = np.copy(all_array['flux']) gross = np.copy(all_array['gross']) flux_err = np.sqrt(gross) / gross time_err = stepsize / 2. / second_per_mjd poisson = np.sqrt(np.mean(gross)) / np.mean( gross) #approximate relative poisson noise across observations standard_deviation = np.std(fluxes) #times= (times - times[0]) *time_converter #fold_times = times%period #plt.figure(figsize= (20,9)) #ax2.axhline(y= 1, linestyle= '-', color = 'm', xmin = 0, xmax = 100000, linewidth = 1, alpha = 0.2) ax2.axhline(y=0, linestyle='-', color='k', xmin=0, xmax=100000, linewidth=1, alpha=0.5) def sig_barriers(sigma, color_line): ax2.axhline(y=3 * sigma, linestyle=':', color=color_line, xmin=0, xmax=100000, linewidth=1) ax2.axhline(y=-3 * sigma, linestyle=':', color=color_line, xmin=0, xmax=100000, linewidth=1) sig_barriers(poisson, 'r') sig_barriers(standard_deviation, 'b') min_time = np.min(times) max_time = np.max(times) #gain_change_list_mjd = Time(config.gain_change_list, scale= 'utc').mjd #for gain_change in gain_change_list_mjd: ##if ((fppos > times.min) & (fppos < times.max)): #if ((gain_change > min_time) & (gain_change< max_time)): #ax2.axvline(x= gain_change ,linestyle = '-', color = 'r' , ymin = -10, ymax = 10, linewidth = 1, alpha = 0.2) #for lpos in config.lpos_list: ##if ((fppos > times.min) & (fppos < times.max)): #if ((lpos > min_time) & (lpos < max_time)): #ax2.axvline(x= lpos,linestyle = '-', color = 'k' , ymin = -10, ymax = 10, linewidth = 1, alpha = 0.8) gain_change_list_bmjd = Time(config.gain_change_list, scale='utc') gain_change_list_bmjd = gain_change_list_bmjd.tdb.mjd for gain_change in gain_change_list_bmjd: #if ((fppos > times.min) & (fppos < times.max)): if ((gain_change > min_time) & (gain_change < max_time)): ax2.axvline(x=gain_change, linestyle='-', color='r', ymin=-10, ymax=10, linewidth=1, alpha=0.2) for lpos in Time(config.lpos_list, format='mjd', scale='utc').tdb.mjd: #if ((fppos > times.min) & (fppos < times.max)): if ((lpos > min_time) & (lpos < max_time)): ax2.axvline(x=lpos, linestyle='-', color='k', ymin=-10, ymax=10, linewidth=1, alpha=0.8) #ax2.scatter(times, fluxes) ax2.errorbar(times, fluxes, flux_err, time_err, fmt='o') #ax2.set_xlabel("Time ("+ time_string + ")") #ax2.set_xlabel("Time (MJD)") ax2.set_xlabel("Time(BMJD_TDB)") ax2.set_ylabel("Flux (normed and zeroed)") plt.text(0.1, 0.9, "standard deviation: " + str(standard_deviation) + "\navg gross counts: " + str(np.mean(gross)), transform=ax2.transAxes, bbox=dict(facecolor='blue', alpha=0.2)) #ax2.set_xlim(0, period) #ax2.set_title(lcfile + ' Period fold '+ str(period) + ' ' + time_string) ax2.set_title(lcfile) #plt.show() fig.tight_layout() #plt.show() #fig.savefig(dest_dir+ target_dir + '_dual_plot_fold_'+ str(period) + unit_arg+'_step' + str(stepsize)+ '_wlim' + str(wave_min) + ',' + str(wave_max)+'.pdf', bbox_inches = 'tight') print('saving') fig.savefig(dest_dir + target_dir + '_dual_plot_step' + str(stepsize) + '_wlim' + str(wave_min) + ',' + str(wave_max) + '.pdf', bbox_inches='tight') print('saved') plt.close( fig ) #close the figure so we don't have memory usage get out of hand return '' except UnboundLocalError as error: print(error) print("guess we're just not working or something") return ""
original_stand_flux, label='original model points', linestyle='None', marker='o', color='magenta') plt.plot(obs_waves1, interp_model_flux, label='interpolated') plt.plot(stand_waves1, stand_flux1, label='model') plt.plot(obs_waves1, other_interp_flux, label='original model interpolated') plt.legend(loc='best') plt.show() obs_spec = np.vstack([obs_waves1, obs_flux1]) #stand_spec= np.vstack([stand_waves1, stand_flux1]) stand_spec = np.vstack([obs_waves1, interp_model_flux]) obs_spec = spt.clean_spectrum(obs_spec, min_wave, max_wave, wavelength_masks) unmasked_stand_spec = spt.clean_spectrum(stand_spec, min_wave, max_wave, standard_info['balmer_masks']) stand_spec = spt.clean_spectrum(stand_spec, min_wave, max_wave, wavelength_masks) stand_waves = stand_spec[0] stand_flux = stand_spec[1] obs_waves = obs_spec[0] obs_flux = obs_spec[1] plt.title('model versus observed') plt.plot(stand_waves, stand_flux, label='model') plt.plot(obs_waves, obs_flux, label='observed') #plt.legend() #plt.show() spt.show_plot()
plt.axhline(y=0, linestyle='--', color='k') #plt.legend() plt.title(filename + ' & ' + filename2.split('/')[-1]) #plt.show() spt.show_plot(line_id='alkali') if file_setting == 'all_SDSS': for filename1 in filenames: target_spec1, header1, target_noise1 = spt.retrieve_sdss_spec( filename1) target_spec1 = norm_spectrum(target_spec1, norm_range) for filename2 in sdss_names: target_spec2, header2, target_noise2 = spt.retrieve_sdss_spec( filename2) target_spec2 = spt.clean_spectrum(target_spec2, np.nanmin(target_spec1[0]), np.nanmax(target_spec1[0]), []) target_spec2 = norm_spectrum(target_spec2, norm_range) plt.ylim(top=np.nanpercentile( np.hstack([target_spec2[1], target_spec1[1]]), 99.9) + 0.5) plot_spectrum(target_spec1, filename1.split('/')[-1], header1, norm=True, smooth=True, kernel_type='box', pix_width=sdss_pix_width) plot_spectrum(target_spec2, filename2.split('/')[-1], header2, norm=True,
def run_spectral_exam(wave_limits): wave_min = wave_limits[0] #lyman = [1208, 1225] #oxygen= [1295, 1312] #airglow wavelengths to be filtered according to lightcurve wave_max = wave_limits[1] #lcbase= target_dir+ '_grid_lightcurves/' + '*step' + str(stepsize) + '_*'+str(wave_min)+',' + str(wave_max)+'*' #lcfile= glob(lcbase)[0] dest_dir = 'segmented_spectra/' + target_dir + '/' if not os.path.exists(dest_dir): os.makedirs(dest_dir) for dataset in glob(target_dir + '/*x1dsum.fits'): hdu = fits.open(dataset) print(dataset, hdu[0].header['OPT_ELEM'], hdu[0].header['CENWAVE'], hdu[1].header['EXPTIME']) def plot_element_lines(wavelength_array, axis_variable): for this_line in config.silicon_lines: if ((this_line > np.nanmin(wavelength_array)) & (this_line < np.nanmax(wavelength_array))): axis_variable.axvline(x=this_line, linestyle='-', color='g', ymin=0, ymax=100000, linewidth=1, alpha=0.9) def remove_range(wave_array, other_array, bound_list): """ Removes wavelengths and flux values from the array that fall in the range specified by bound_list """ lower_bound = bound_list[0] upper_bound = bound_list[1] low_mask = np.where(wave_array < lower_bound) high_mask = np.where(wave_array > upper_bound) low_waves = wave_array[low_mask] high_waves = wave_array[high_mask] low_other = other_array[low_mask] high_other = other_array[high_mask] merge_waves = np.append(low_waves, high_waves) merge_other = np.append(low_other, high_other) return merge_waves, merge_other def zero_mask(wave_array, other_array, bound_list): lower_bound = bound_list[0] upper_bound = bound_list[1] masking = np.where((wave_array > lower_bound) & (wave_array < upper_bound)) other_array[masking] = 0. return other_array counter = 0 vertical_dimension = 6 max_points_per_window = 501 for dataset in glob(target_dir + '/*x1dsum.fits'): hdu = fits.open(dataset) #print(hdu[1]) #print(hdu[1]['FUVA']) #print(hdu[1].data[0]) #print(hdu[1].data.shape) #for thing in hdu[1].data: #print("thing: ", thing) #print(thing['wavelength']) wavelengths = np.copy(hdu[1].data['wavelength'].ravel()) print(wavelengths.shape) fluxes = np.copy(hdu[1].data['flux'].ravel()) #print("fluxes", fluxes) arrshape = wavelengths.shape #unmasked= np.where((wavelengths < lyman[0]*np.ones(arrshape)) or ((wavelengths > lyman[1]*np.ones(arrshape)) and (wavelengths < oxygen[0])*np.ones(arrshape)) or (wavelengths > oxygen[1]*np.ones(arrshape))) target_spec = np.vstack([wavelengths, fluxes]) mask_list = [config.lyman_mask] + [config.oxygen_mask] + [ config.nitrogen_mask ] #need to add the segment gap in the future cleaned_spec = spt.clean_spectrum(target_spec, wave_min, wave_max, mask_list) wavelengths = cleaned_spec[0] fluxes = cleaned_spec[1] #lower_mask = np.where(wavelengths > wave_min) #wavelengths= np.copy(wavelengths[lower_mask]) #fluxes = np.copy(fluxes[lower_mask]) #upper_mask= np.where(wavelengths < wave_max) #wavelengths= np.copy(wavelengths[upper_mask]) #fluxes= np.copy(fluxes[upper_mask]) #print("fluxes.shape: ", fluxes.shape) #wavelengths, fluxes = remove_range(wavelengths, fluxes, config.lyman_mask) #wavelengths, fluxes = remove_range(wavelengths, fluxes, config.oxygen_mask) #wavelengths, fluxes = remove_range(wavelengths, fluxes, config.nitrogen_mask) #fluxes= zero_mask(wavelengths, fluxes, config.lyman_mask) #fluxes= zero_mask(wavelengths, fluxes, config.oxygen_mask) print("fluxes.shape: ", fluxes.shape) print("wavelengths.shape", wavelengths.shape) if counter == 0: flux_all = np.array([np.zeros(fluxes.shape)]) print("flux_all.shape: ", flux_all.shape) plot_waves = wavelengths print("wavelengths differences", plot_waves[:5] - wavelengths[:5]) print(plot_waves[:5]) print(wavelengths[:5]) try: flux_all = np.append(flux_all, [fluxes], axis=0) print(flux_all.shape) except ValueError as error: print(error) shape_dif = flux_all.shape[1] - fluxes.shape[0] if shape_dif > 0: padarray = np.zeros(shape_dif) fluxes_pad = np.append(fluxes, padarray) flux_all = np.append(flux_all, [fluxes_pad], axis=0) elif shape_dif < 0: flux_all = np.append(flux_all, [fluxes[:shape_dif]], axis=0) print("truncating new spectrum to match previous dimensions") #try: ##flux_all = np.copy(fluxes+flux_all) #except ValueError as error: #print(error) #shape_dif = flux_all.shape[0] - fluxes.shape[0] #if shape_dif > 0 : #padarray= np.zeros(shape_dif) #flux_all= np.copy(flux_all + np.append(fluxes, padarray)) #elif shape_dif < 0 : #flux_all= np.copy(flux_all + fluxes[:shape_dif]) counter += 1 #print("sum fluxes: ", np.sum(fluxes)) #ax1.plot(wavelengths, fluxes/np.nanmean(fluxes), label=hdu[0].header['rootname']) num_segs = plot_waves.shape[0] // max_points_per_window + 1 #silicon_lines= [1190, 1193, 1195, 1197, 1207, 1260, 1265, 1304, 1309] flux_all = flux_all[1:, :] #remove the first row of zeros flux_med = np.nanmedian(flux_all, axis=0) #flux_normed = flux_med/np.nanmean(flux_med) #changed this so it's actually not normalized flux_normed = flux_med needed_zeros = max_points_per_window - plot_waves.shape[ 0] % max_points_per_window flux_normed = np.append(flux_normed, np.zeros(needed_zeros)) dlambda = plot_waves[-1] - plot_waves[-2] #find the wavelength bin size plus_lambda = dlambda * np.indices([ needed_zeros, ])[0] #find vaues that need to be added to get out to the appropriate range plus_lambda = plus_lambda + plot_waves[-1] print("plus_lambda.shape:", plus_lambda.shape) plot_waves = np.append( plot_waves, plus_lambda ) #tack on the necessary wavelength values on the far end of the spectrum to get it farther without having to deal with all of the associated noise. #now reshape both plot_waves and flux_normed to be multidimensional arrays that we can iterate through. #output a long version of the spectrum as well longfig = plt.figure(figsize=(200, 12)) longax = longfig.add_subplot(1, 1, 1) longax.plot(plot_waves, flux_normed, color='k') plot_element_lines(plot_waves, longax) plt.grid() #longax.set_ylabel('Flux (normed)') longax.set_ylabel('Flux (cgs units)') longax.set_xlabel('Wavelength $(\AA)$') longfig.savefig(dest_dir + target_dir + 'long_spectrum_' + str(wave_limits[0]) + ',' + str(wave_limits[1]) + '.pdf') plot_waves = plot_waves.reshape(num_segs, max_points_per_window) flux_normed = flux_normed.reshape(num_segs, max_points_per_window) num_mults_42 = num_segs // 42 #42 is the maximum number of subplots allowed figsaves = 0 if num_segs > 42: for gorounds in range(0, num_mults_42): offset = 42 * gorounds new_max = 42 fig = plt.figure(figsize=(20, new_max * vertical_dimension)) for segment in range(0, new_max): ax = fig.add_subplot(new_max, 1, segment + 1) waves_for_plot = plot_waves[segment + offset] flux_for_plot = flux_normed[segment + offset] plot_element_lines(waves_for_plot, ax) #for this_line in config.silicon_lines: #if ((this_line > np.nanmin(waves_for_plot)) & (this_line< np.nanmax(waves_for_plot))): #ax.axvline(x= this_line ,linestyle = '-', color = 'g' , ymin = 0, ymax = 100000, linewidth = 1, alpha = 0.2) #print(flux_all.shape) ax.plot(waves_for_plot, flux_for_plot, color='k') #ax.set_ylabel('Flux (normed)') ax.set_ylabel('Flux (cgs units)') ax.set_xlabel('Wavelength $(\AA)$') ax.set_xlim( [np.nanmin(waves_for_plot), np.nanmax(waves_for_plot)]) fig.tight_layout() plt.title(target_dir) fig.savefig(dest_dir + target_dir + 'segmented_spectra_wlim' + str(wave_limits[0]) + ',' + str(wave_limits[1]) + '_fig' + str(figsaves) + '.pdf') figsaves += 1 #plt.show() #and now the remaining segments: offset = 42 * num_mults_42 fig = plt.figure(figsize=(20, num_segs * vertical_dimension)) for segment in range(0, num_segs % 42): ax = fig.add_subplot(num_segs, 1, segment + 1) waves_for_plot = plot_waves[segment + offset] flux_for_plot = flux_normed[segment + offset] for this_line in config.silicon_lines: if ((this_line > np.nanmin(waves_for_plot)) & (this_line < np.nanmax(waves_for_plot))): ax.axvline(x=this_line, linestyle='-', color='g', ymin=0, ymax=100000, linewidth=1, alpha=0.2) #print(flux_all.shape) ax.plot(waves_for_plot, flux_for_plot, color='k') ax.set_ylabel('Flux (normed)') ax.set_xlabel('Wavelength $(\AA)$') ax.set_xlim([np.nanmin(waves_for_plot), np.nanmax(waves_for_plot)]) fig.tight_layout() plt.title(target_dir) fig.savefig(dest_dir + target_dir + 'segmented_spectra_wlim' + str(wave_limits[0]) + ',' + str(wave_limits[1]) + '_fig' + str(figsaves) + '.pdf') figsaves += 1 else: print("Currently not well-configured to handle fewer than 42 segments") print("That corresponds to " + str(max_points_per_window * 42) + ' data points in the set.') fig = plt.figure(figsize=(20, num_segs * vertical_dimension)) for segment in range(0, num_segs): ax = fig.add_subplot(num_segs, 1, segment + 1) waves_for_plot = plot_waves[segment] flux_for_plot = flux_normed[segment] for this_line in config.silicon_lines: if ((this_line > np.nanmin(waves_for_plot)) & (this_line < np.nanmax(waves_for_plot))): ax.axvline(x=this_line, linestyle='-', color='g', ymin=0, ymax=100000, linewidth=1, alpha=0.2) #print(flux_all.shape) ax.plot(waves_for_plot, flux_for_plot, color='k') ax.set_ylabel('Flux (normed)') ax.set_xlabel('Wavelength $(\AA)$') ax.set_xlim([np.nanmin(waves_for_plot), np.nanmax(waves_for_plot)]) fig.tight_layout() plt.title(target_dir) fig.savefig(dest_dir + target_dir + 'segmented_spectra_wlim' + str(wave_limits[0]) + ',' + str(wave_limits[1]) + '_fig' + str(figsaves) + '.pdf') figsaves += 1