def find_shift(data_type,data_spectrum,teff,logg,feh,start_lambda,end_lambda): ### Import the template spectrum template_spectrum = "template_" + str(teff) + "_" + str(logg) + "_" + str(feh) + ".dat" if data_type=="flux": template_spectrum = functions.read_ascii(model_path_flux + template_spectrum) if data_type=="norm": template_spectrum = functions.read_ascii(model_path_norm + template_spectrum) template_spectrum = functions.read_table(template_spectrum) template_spectrum = transpose(array(template_spectrum)) if data_type=="flux": template_spectrum =spectype_functions.normalise(template_spectrum,flux_normalise_w1,flux_normalise_w2) ### Chop both spectra data_region = spectype_numerical_functions.chop_spectrum(data_spectrum,start_lambda,end_lambda) template_region = spectype_numerical_functions.chop_spectrum(template_spectrum,start_lambda,end_lambda) ### Conform template spectrum to data spectrum -> same wavelength scale template_region = spectype_numerical_functions.conform_spectrum(data_region,template_region) ### Find shift chisq_shift = [] shift_limit = 20 shift = -1*shift_limit while shift <= shift_limit: data_region_shifted,template_region_shifted = spectype_functions.shift_spectrum(data_region,template_region,shift) chisq_shift.append(spectype_numerical_functions.chisq(data_region_shifted,template_region_shifted)) shift = shift + 1 chisq_min = spectype_functions.find_min(chisq_shift) best_shift = chisq_min - shift_limit return best_shift
def test_template(data_type,data_spectrum,teff,logg,feh,start_lambda,end_lambda,shift): ### Import a template spectrum - test template_spectrum = "template_" + str(teff) + "_" + str(logg) + "_" + str(feh) + ".dat" if data_type=="flux": template_spectrum = functions.read_ascii(model_path_flux + template_spectrum) if data_type=="norm": template_spectrum = functions.read_ascii(model_path_norm + template_spectrum) template_spectrum = functions.read_table(template_spectrum) template_spectrum = transpose(array(template_spectrum)) if data_type=="flux": template_spectrum = spectype_functions.normalise(template_spectrum,flux_normalise_w1,flux_normalise_w2) ### Chop both spectra data_region = spectype_numerical_functions.chop_spectrum(data_spectrum,start_lambda,end_lambda) template_region = spectype_numerical_functions.chop_spectrum(template_spectrum,start_lambda,end_lambda) ### Conform template spectrum to data spectrum -> same wavelength scale template_region = spectype_numerical_functions.conform_spectrum(data_region,template_region) ### Find shift data_region_shifted,template_region_shifted = spectype_functions.shift_spectrum(data_region,template_region,shift) chisq = spectype_numerical_functions.chisq(data_region_shifted,template_region_shifted) # plt.clf() # plt.plot(data_region_shifted[0],data_region_shifted[1]) # plt.plot(template_region_shifted[0],template_region_shifted[1]) # plt.title(data_type + " " + str(teff) + " " + str(logg) + " " + str(feh) +" " + str(chisq)) # plt.show() return chisq
def loop_input_spectrum(input_wave,input_flux,folder,teff_space,logg_space,feh_space,w1,w2,perform_normalise): data = [] for teff in teff_space: for logg in logg_space: for feh in feh_space: template_spectrum = "template_" + str(teff) + "_" + str(logg) + "_" + str(feh)+".dat" #print folder + template_spectrum template_spectrum = functions.read_ascii(folder+template_spectrum) template_spectrum = functions.read_table(template_spectrum) template_spectrum = transpose(array(template_spectrum)) if folder == model_path_flux: template_spectrum = spectype_functions.normalise(template_spectrum,flux_normalise_w1,flux_normalise_w2) i1 = w1 - min(input_wave) i2 = w2 - min(input_wave) input_wave_cropped = input_wave[i1:i2] input_flux_cropped = input_flux[i1:i2] template_spectrum = spectype_numerical_functions.chop_spectrum(template_spectrum,w1-10,w2+10) template_interp = interpolate.splrep(template_spectrum[0],template_spectrum[1],s=0) template_flux = interpolate.splev(input_wave_cropped,template_interp,der=0) sigma = 3.0 if perform_normalise: diff_flux = input_flux_cropped/median(input_flux_cropped) - template_flux/median(template_flux) else: diff_flux = input_flux_cropped - template_flux diff_flux = clip(diff_flux,median(diff_flux) - sigma*std(diff_flux),median(diff_flux)+sigma*std(diff_flux)) rms = sqrt(sum(diff_flux**2) /float(len(input_wave_cropped))) # plt.clf() # plt.plot(input_wave_cropped,input_flux_cropped/median(input_flux_cropped)) # plt.plot(input_wave_cropped,template_flux/median(template_flux)) # plt.show() # #sys.exit() #print rms data.append(rms) return data
default_teff = float(functions.read_config_file("TEFF_ESTIMATE")) default_logg = float(functions.read_config_file("LOGG_ESTIMATE")) teff_ini,logg_ini = functions.estimate_teff_logg(object_name,hsmso_connect,hscand_connect,default_teff,default_logg) feh_ini = 0.0 print "Initial estimate of teff, logg: ",str(teff_ini),str(logg_ini) ### Change directory to reduced/ program_dir = os.getcwd() + "/" #Save the current working directory os.chdir(file_path_reduced) #Change to ../reduced/ dir ### Load in spectra flux_spectrum = functions.read_ascii("fluxcal_" + file_name + ".dat") flux_spectrum = functions.read_table(flux_spectrum) flux_spectrum = transpose(array(flux_spectrum)) flux_spectrum = spectype_functions.normalise(flux_spectrum,flux_normalise_w1,flux_normalise_w2) norm_spectrum = functions.read_ascii("norm_" + file_name + ".dat") norm_spectrum = functions.read_table(norm_spectrum) norm_spectrum = transpose(array(norm_spectrum)) print "Using specific regions for spectral typing" ### Check the temp and define which logg sensitive regions to use #if teff_ini > 4750 and teff_ini < 5750: if teff_ini > 4750 and teff_ini < 6250: #logg_regions = [[5140,5235]] logg_regions = [[5100,5400]] if teff_ini <= 4750 and teff_ini > 4250: logg_regions = [[5100,5400]] if teff_ini <= 4250: logg_regions = [[4730,4810]]
def plot_spectrum(rms_data,input_spectrum): rms_data = functions.read_ascii(rms_data) rms_data = functions.read_table(rms_data) rms_data = transpose(rms_data) ### Find min for i in range(len(rms_data[0])): if rms_data[3][i] == min(rms_data[3]): teff_min = rms_data[0][i] logg_min = rms_data[1][i] feh_min = rms_data[2][i] break print teff_min,logg_min,feh_min teff_list = [] logg_list = [] rms_list = [] for i in range(len(rms_data[0])): if rms_data[2][i] == feh_min: teff_list.append(rms_data[0][i]) logg_list.append(rms_data[1][i]) rms_list.append(rms_data[3][i]) plt.subplot(211) cm = matplotlib.cm.get_cmap('jet') sc = plt.scatter(teff_list, logg_list, c=rms_list, vmin=min(rms_list), vmax=max(rms_list), s=70, cmap=cm,edgecolor="w") cbar = plt.colorbar(sc) cbar.ax.set_ylabel("RMS") plt.scatter(teff_min,logg_min,color="r",s=70,marker="+") spectype_functions.plot_isochrones(program_dir,"r-",1) plt.xlim(max(teff_list)+250,min(teff_list)-250) plt.ylim(max(logg_list)+.25,min(logg_list)-0.25) plt.xlabel("Teff (K)") plt.ylabel("Logg") plt.subplot(212) data_spectrum = functions.read_ascii(input_spectrum) data_spectrum = functions.read_table(data_spectrum) data_spectrum = transpose(array(data_spectrum)) data_spectrum = spectype_functions.normalise(data_spectrum,flux_normalise_w1,flux_normalise_w2) template_spectrum = "template_" + str(int(teff_min)) + "_" + str(logg_min) + "_" + str(feh_min)+".dat" template_spectrum = functions.read_ascii(model_path_flux+template_spectrum) template_spectrum = functions.read_table(template_spectrum) template_spectrum = transpose(array(template_spectrum)) template_spectrum = spectype_functions.normalise(template_spectrum,flux_normalise_w1,flux_normalise_w2) plt.plot(data_spectrum[0],data_spectrum[1],"b-") plt.plot(template_spectrum[0],template_spectrum[1],"g-") plt.xlim(3700,5800) plt.xlabel("Wavelength (A)") plt.ylabel("Normalised flux") plt.show()
def plot_spectrum(rms_data,input_spectrum): print "Plotting ",input_spectrum rms_data = functions.read_ascii(rms_data) rms_data = functions.read_table(rms_data) rms_data = transpose(rms_data) ### Find min for i in range(len(rms_data[0])): if rms_data[3][i] == min(rms_data[3]): teff_min = rms_data[0][i] logg_min = rms_data[1][i] feh_min = rms_data[2][i] break print teff_min,logg_min,feh_min,min(rms_data[3]) teff_list = [] logg_list = [] rms_list = [] for i in range(len(rms_data[0])): if rms_data[2][i] == feh_min: teff_list.append(rms_data[0][i]) logg_list.append(rms_data[1][i]) rms_list.append(rms_data[3][i]) ### Create 2D space teff_space = arange(min(teff_list),max(teff_list)+250,250) logg_space = arange(min(logg_list),max(logg_list)+0.5,0.5) rms_space = zeros([len(teff_space),len(logg_space)]) for i in range(len(rms_list)): x_index = int((teff_list[i] - min(teff_list)) / 250.) y_index = int((logg_list[i] - min(logg_list)) / 0.5) rms_space[x_index,y_index] = rms_list[i] ### Crop 2D space to perform gaussian fit for min teff_space_cropped,logg_space_cropped,rms_space_cropped=spectype_functions.chop_array(teff_space,logg_space,transpose(rms_space),teff_min,logg_min,250,0.5) rms_space_cropped = -1*(rms_space_cropped - rms_space_cropped.max()) print rms_space_cropped try: gauss_fit = spectype_functions.fitgaussian(rms_space_cropped) teff_min_fit = min(teff_space_cropped) + gauss_fit[2] * 250 logg_min_fit = min(logg_space_cropped) + gauss_fit[1] * 0.5 except TypeError: print "Bad gaussian fit, using abs min" teff_min_fit = teff_min logg_min_fit = logg_min if teff_min_fit < 3500: teff_min_fit = 3500 if teff_min_fit > 9000: teff_min_fit = 9000 if logg_min_fit < 0.0: logg_min_fit = 0.0 if logg_min_fit > 5.0: logg_min_fit = 5.0 teff_min = int(spectype_functions.round_value(teff_min_fit,250.)) logg_min = spectype_functions.round_value(logg_min_fit,0.5) print teff_min,logg_min ### Plot teff_logg space plt.figure(figsize=(7,5)) plt.subplot(211) plt.title(object_name+" "+file_name+" "+str(int(round(teff_min_fit,0)))+" "+str(round(logg_min_fit,1))+" "+str(feh_min)+" \n RMS="+str(round(min(rms_data[3]),4))) v_min = min(rms_list) v_max = min(rms_list)+((max(rms_list)-min(rms_list))/3.) #v_max = max(rms_list) rms_space = clip(rms_space,v_min,v_max) cm = matplotlib.cm.get_cmap('jet') sc = plt.contourf(teff_space,logg_space,transpose(rms_space),100,cmap=cm) #sc = plt.scatter(teff_list, logg_list, c=rms_list, vmin=min(rms_list), vmax=(max(rms_list)-min(rms_list))/3+min(rms_list), s=150, cmap=cm,edgecolor="w") cbar = plt.colorbar(sc) cbar.ax.set_ylabel("RMS") plt.scatter(teff_min_fit,logg_min_fit,color="r",s=70,marker="+") spectype_functions.plot_isochrones(program_dir,"r-",1) plt.xlim(max(teff_list),min(teff_list)) plt.ylim(max(logg_list),min(logg_list)) #plt.xlim(max(teff_list)+250,min(teff_list)-250) #plt.ylim(max(logg_list)+.25,min(logg_list)-0.25) plt.xlabel("Teff (K)") plt.ylabel("Logg") ### Plot spectrum plt.subplot(212) data_spectrum = functions.read_ascii(input_spectrum) data_spectrum = functions.read_table(data_spectrum) data_spectrum = transpose(array(data_spectrum)) data_spectrum = spectype_functions.normalise(data_spectrum,flux_normalise_w1,flux_normalise_w2) template_spectrum = "template_" + str(int(teff_min)) + "_" + str(logg_min) + "_" + str(feh_min)+".dat" template_spectrum = functions.read_ascii(model_path_flux+template_spectrum) template_spectrum = functions.read_table(template_spectrum) template_spectrum = transpose(array(template_spectrum)) template_spectrum = spectype_functions.normalise(template_spectrum,flux_normalise_w1,flux_normalise_w2) data_wave = data_spectrum[0] data_flux = data_spectrum[1] template_wave = template_spectrum[0] template_flux = template_spectrum[1] c = 3.0 * 10**5 data_wave = data_wave / ((vel_shift / c) + 1) data_interp = interpolate.splrep(data_wave,data_flux,s=0) data_flux = interpolate.splev(master_flux_wave,data_interp,der=0) template_interp = interpolate.splrep(template_wave,template_flux,s=0) template_flux = interpolate.splev(master_flux_wave,template_interp,der=0) plt.plot(master_flux_wave,data_flux,"b-",label="data") plt.plot(master_flux_wave,template_flux,"g-",label="template") plt.xlim(3600,5800) ylim_range = max(template_flux)-min(template_flux) plt.ylim(min(template_flux)-ylim_range*0.2,max(template_flux)+ylim_range*0.2) plt.legend(loc="lower right",ncol=2) plt.xlabel("Wavelength (A)") plt.ylabel("Normalised flux") os.system("rm "+file_path_reduced+"spectype_plots/"+object_name+"_"+file_name+".pdf") plt.savefig(file_path_reduced+"spectype_plots/"+object_name+"_"+file_name+".pdf") #plt.show() return teff_min_fit,logg_min_fit,feh_min
def calculate_spectral_params(teff_ini,logg_ini,feh_ini): def find_shift(input1,input2,i1,i2,shift_range): if abs(i2 - i1) < 300: i1 = i1 - 150 i2 = i2 + 150 if i1 < 0: i1 = 0 i2 = 300 if i2 > len(input1): i2 = len(input1) i1 = len(input1) - 300 ### Use xcorr currdir = os.getcwd() os.chdir(file_path_reduced) os.system("rm "+file_path_reduced+"shift_spec*") input1_cropped = input1[i1:i2]/median(input1[i1:i2]) input2_cropped = input2[i1:i2]/median(input1[i1:i2]) wave_axis = arange(1,len(input1_cropped)+1) shift_spec1 = open(file_path_reduced+"shift_spec1.txt","w") functions.write_table(transpose([wave_axis,input1_cropped]),shift_spec1) shift_spec1.close() shift_spec2 = open(file_path_reduced+"shift_spec2.txt","w") functions.write_table(transpose([wave_axis,input2_cropped]),shift_spec2) shift_spec2.close() iraf.rspectext( input = file_path_reduced+"shift_spec1.txt",\ output = file_path_reduced+"shift_spec1.fits",\ title = "shift_spec1",\ flux = 0,\ dtype = "interp",\ crval1 = "",\ cdelt1 = "",\ fd1 = "",\ fd2 = "") iraf.rspectext( input = file_path_reduced+"shift_spec2.txt",\ output = file_path_reduced+"shift_spec2.fits",\ title = "shift_spec2",\ flux = 0,\ dtype = "interp",\ crval1 = "",\ cdelt1 = "",\ fd1 = "",\ fd2 = "") time.sleep(0.5) ### Find shift os.system("rm apshift*") ### Makesure keywpars is set at default iraf.unlearn(iraf.keywpars) cuton = len(input1_cropped)/25. cutoff = len(input1_cropped)/2.5 iraf.filtpars.setParam("f_type","welch",check=1,exact=1) iraf.filtpars.setParam("cuton",cuton,check=1,exact=1) iraf.filtpars.setParam("cutoff",cutoff,check=1,exact=1) run_fxcor(file_path_reduced+"shift_spec1.fits",file_path_reduced+"shift_spec2.fits","*","apshift",0,10,"gaussian","INDEF",0) vel_shift = functions.read_ascii("apshift.txt") vel_shift = functions.read_table(vel_shift) vel_shift = vel_shift[0][6] if vel_shift == "INDEF": vel_shift = 0.0 if abs(vel_shift) > shift_range: vel_shift = 0.0 print "best pixel shift of ",vel_shift os.system("rm apshift*") os.system("rm "+file_path_reduced+"shift_spec*") os.chdir(currdir) #if i1 < shift_range: # i1 = shift_range #if i2 > len(input1)-shift_range: # i2 = len(input1)-shift_range # shift_rms = [] # shift_list = [] # for shift in range(-1*shift_range,shift_range+1): # input1_cropped = input1[i1+shift:i2+shift] # input2_cropped = input2[i1:i2] # diff = input1_cropped/median(input1_cropped) * input2_cropped/median(input2_cropped) # rms = sum(diff) # #rms = sqrt(sum(diff**2) /float(len(diff))) # shift_rms.append(rms) # shift_list.append(shift) # for i in range(len(shift_rms)): # if shift_rms[i] == max(shift_rms): # break # print "Applying a shift of ",shift_list[i] # plt.clf() # plt.plot(input1[i1+shift_list[i]:i2+shift_list[i]]/median(input1[i1+shift_list[i]:i2+shift_list[i]]),"b-") # plt.plot(input1[i1:i2]/median(input1[i1:i2]),"r-") # plt.plot(input2[i1:i2]/median(input2[i1:i2]),"g-") # plt.show() # return shift_list[i] return int(round(vel_shift,0)) def loop_input_spectrum(input_wave,input_flux,folder,teff_space,logg_space,feh_space,w1,w2,perform_normalise,shift_range,fix_feh): i1 = w1 - min(input_wave) i2 = w2 - min(input_wave) shift = 0 if shift_range > 0: i = 0 for teff in teff_space: for logg in logg_space: for feh in feh_space: if teff == teff_ini and logg == logg_ini and feh == feh_ini: if folder == model_path_flux: template_flux = spec_database[i] if folder == model_path_norm: template_flux = normspec_database[i] try: shift = find_shift(input_flux,template_flux,i1,i2,shift_range) except iraf.IrafError: print "IRAF fxcor stupid error, setting shift to 0" shift = 0 break else: i = i+1 i = 0 data = [] for teff in teff_space: for logg in logg_space: for feh in feh_space: if fix_feh: feh_0_index = int((0 - feh)/0.5) else: feh_0_index = 0 if folder == model_path_flux: template_flux = spec_database[i+feh_0_index] if folder == model_path_norm: template_flux = normspec_database[i+feh_0_index] input_wave_cropped = input_wave[i1+shift:i2+shift] input_flux_cropped = input_flux[i1+shift:i2+shift] template_flux_cropped = template_flux[i1:i2] sigma = 10.0 if perform_normalise: diff_flux = input_flux_cropped/median(input_flux_cropped) - template_flux_cropped/median(template_flux_cropped) else: diff_flux = input_flux_cropped - template_flux_cropped diff_flux = clip(diff_flux,median(diff_flux) - sigma*std(diff_flux),median(diff_flux)+sigma*std(diff_flux)) rms = sqrt(sum(diff_flux**2) /float(len(input_wave_cropped))) # shift_rms = [] # shift_range = 0 # for shift in range(-1*shift_range,shift_range+1): # input_wave_cropped = input_wave[i1:i2] # input_flux_cropped = input_flux[i1:i2] # template_flux_cropped = template_flux[i1+shift:i2+shift] # sigma = 5.0 # if perform_normalise: # diff_flux = input_flux_cropped/median(input_flux_cropped) - template_flux_cropped/median(template_flux_cropped) # else: # diff_flux = input_flux_cropped - template_flux_cropped # diff_flux = clip(diff_flux,median(diff_flux) - sigma*std(diff_flux),median(diff_flux)+sigma*std(diff_flux)) # rms = sqrt(sum(diff_flux**2) /float(len(input_wave_cropped))) # shift_rms.append(rms) # rms = min(shift_rms) ### Weight against feh feh_index = (feh - min(feh_space))/0.5 logg_index = (logg - min(logg_space))/0.5 rms = rms * feh_weights[int(feh_index)] * logg_weights[int(logg_index)] # plt.clf() # plt.plot(input_wave_cropped,input_flux_cropped/median(input_flux_cropped)) # plt.plot(input_wave_cropped,template_flux_cropped/median(template_flux_cropped)) # plt.plot(input_wave_cropped,diff_flux) # plt.show() # #sys.exit() # print rms data.append(rms) i = i+1 return data def plot_spectrum(rms_data,input_spectrum): print "Plotting ",input_spectrum rms_data = functions.read_ascii(rms_data) rms_data = functions.read_table(rms_data) rms_data = transpose(rms_data) ### Find min for i in range(len(rms_data[0])): if rms_data[3][i] == min(rms_data[3]): teff_min = rms_data[0][i] logg_min = rms_data[1][i] feh_min = rms_data[2][i] break print teff_min,logg_min,feh_min,min(rms_data[3]) teff_list = [] logg_list = [] rms_list = [] for i in range(len(rms_data[0])): if rms_data[2][i] == feh_min: teff_list.append(rms_data[0][i]) logg_list.append(rms_data[1][i]) rms_list.append(rms_data[3][i]) ### Create 2D space teff_space = arange(min(teff_list),max(teff_list)+250,250) logg_space = arange(min(logg_list),max(logg_list)+0.5,0.5) rms_space = zeros([len(teff_space),len(logg_space)]) for i in range(len(rms_list)): x_index = int((teff_list[i] - min(teff_list)) / 250.) y_index = int((logg_list[i] - min(logg_list)) / 0.5) rms_space[x_index,y_index] = rms_list[i] ### Crop 2D space to perform gaussian fit for min teff_space_cropped,logg_space_cropped,rms_space_cropped=spectype_functions.chop_array(teff_space,logg_space,transpose(rms_space),teff_min,logg_min,250,0.5) rms_space_cropped = -1*(rms_space_cropped - rms_space_cropped.max()) print rms_space_cropped try: gauss_fit = spectype_functions.fitgaussian(rms_space_cropped) teff_min_fit = min(teff_space_cropped) + gauss_fit[2] * 250 logg_min_fit = min(logg_space_cropped) + gauss_fit[1] * 0.5 except TypeError: print "Bad gaussian fit, using abs min" teff_min_fit = teff_min logg_min_fit = logg_min if teff_min_fit < 3500: teff_min_fit = 3500 if teff_min_fit > 9000: teff_min_fit = 9000 if logg_min_fit < 0.0: logg_min_fit = 0.0 if logg_min_fit > 5.0: logg_min_fit = 5.0 teff_min = int(spectype_functions.round_value(teff_min_fit,250.)) logg_min = spectype_functions.round_value(logg_min_fit,0.5) print teff_min,logg_min ### Plot teff_logg space plt.figure(figsize=(7,5)) plt.subplot(211) plt.title(object_name+" "+file_name+" "+str(int(round(teff_min_fit,0)))+" "+str(round(logg_min_fit,1))+" "+str(feh_min)+" \n RMS="+str(round(min(rms_data[3]),4))) v_min = min(rms_list) v_max = min(rms_list)+((max(rms_list)-min(rms_list))/3.) #v_max = max(rms_list) rms_space = clip(rms_space,v_min,v_max) cm = matplotlib.cm.get_cmap('jet') sc = plt.contourf(teff_space,logg_space,transpose(rms_space),100,cmap=cm) #sc = plt.scatter(teff_list, logg_list, c=rms_list, vmin=min(rms_list), vmax=(max(rms_list)-min(rms_list))/3+min(rms_list), s=150, cmap=cm,edgecolor="w") cbar = plt.colorbar(sc) cbar.ax.set_ylabel("RMS") plt.scatter(teff_min_fit,logg_min_fit,color="r",s=70,marker="+") spectype_functions.plot_isochrones(program_dir,"r-",1) plt.xlim(max(teff_list),min(teff_list)) plt.ylim(max(logg_list),min(logg_list)) #plt.xlim(max(teff_list)+250,min(teff_list)-250) #plt.ylim(max(logg_list)+.25,min(logg_list)-0.25) plt.xlabel("Teff (K)") plt.ylabel("Logg") ### Plot spectrum plt.subplot(212) data_spectrum = functions.read_ascii(input_spectrum) data_spectrum = functions.read_table(data_spectrum) data_spectrum = transpose(array(data_spectrum)) data_spectrum = spectype_functions.normalise(data_spectrum,flux_normalise_w1,flux_normalise_w2) template_spectrum = "template_" + str(int(teff_min)) + "_" + str(logg_min) + "_" + str(feh_min)+".dat" template_spectrum = functions.read_ascii(model_path_flux+template_spectrum) template_spectrum = functions.read_table(template_spectrum) template_spectrum = transpose(array(template_spectrum)) template_spectrum = spectype_functions.normalise(template_spectrum,flux_normalise_w1,flux_normalise_w2) data_wave = data_spectrum[0] data_flux = data_spectrum[1] template_wave = template_spectrum[0] template_flux = template_spectrum[1] c = 3.0 * 10**5 data_wave = data_wave / ((vel_shift / c) + 1) data_interp = interpolate.splrep(data_wave,data_flux,s=0) data_flux = interpolate.splev(master_flux_wave,data_interp,der=0) template_interp = interpolate.splrep(template_wave,template_flux,s=0) template_flux = interpolate.splev(master_flux_wave,template_interp,der=0) plt.plot(master_flux_wave,data_flux,"b-",label="data") plt.plot(master_flux_wave,template_flux,"g-",label="template") plt.xlim(3600,5800) ylim_range = max(template_flux)-min(template_flux) plt.ylim(min(template_flux)-ylim_range*0.2,max(template_flux)+ylim_range*0.2) plt.legend(loc="lower right",ncol=2) plt.xlabel("Wavelength (A)") plt.ylabel("Normalised flux") os.system("rm "+file_path_reduced+"spectype_plots/"+object_name+"_"+file_name+".pdf") plt.savefig(file_path_reduced+"spectype_plots/"+object_name+"_"+file_name+".pdf") #plt.show() return teff_min_fit,logg_min_fit,feh_min def find_min_index(input_list): for i in range(len(input_list)): if input_list[i] == min(input_list): return i ################# ### Make axes ### ################# teff_space = [] logg_space = [] feh_space = [] teff_min = teff_ini - 750 teff_max = teff_ini + 750 if teff_min < 3500: teff_min = int(3500) if teff_max > 8000: teff_max = int(8000) ### Create grid teff_i = teff_min while teff_i <= teff_max: teff_space.append(teff_i) teff_i = teff_i + 250 logg_i = 0.0 while logg_i <= 5.0: logg_space.append(logg_i) logg_i = logg_i + 0.5 feh_i = -2.5 while feh_i <= 0.5: feh_space.append(feh_i) feh_i = feh_i + 0.5 teff_space = array(teff_space) logg_space = array(logg_space) feh_space = array(feh_space) ###################### ### Define regions ### ###################### print "Using specific regions for spectral typing" ### Check the temp and define which logg sensitive regions to use if teff_ini > 4750 and teff_ini < 5750: #if teff_ini > 4750 and teff_ini < 6250: #logg_regions = [[5140,5235]] logg_regions = [[5100,5400]] if teff_ini <= 4750 and teff_ini > 4250: logg_regions = [[4100,4200],[5100,5400]] if teff_ini <= 4250: logg_regions = [[4720,4970]] #logg_regions = [[3900,4000],[4100,4200],[4300,4400],[4500,4600],[4600,4700],[4700,4900],[4720,4810],[5100,5400]] if teff_ini >= 5750 and teff_ini < 6250: #logg_regions = [[3850,4500]] logg_regions = [[3670,3715],[3900,4000],[5100,5400]] if teff_ini >= 6250: logg_regions = [[3670,3715],[3900,4000]] ### logg_regions = [[4500,5800]] if teff_ini <= 4000: feh_regions = [[4800,5000],[5000,5100],[5200,5500],[4500,5700]] if teff_ini <= 4750 and teff_ini > 4000: feh_regions = [[4450,4500],[4800,5000],[5000,5100],[5200,5500]] if teff_ini <= 5500 and teff_ini > 4750: feh_regions = [[3900,4000],[4450,4500],[5100,5400]] if teff_ini > 5500: feh_regions = [[3900,4100],[4280,4320],[5100,5200]] ### Define the regions used in flux spectra matching # if teff_ini >= 5750: # teff_regions = [[4835,4885],[4315,4365],[4075,4125],[3800,3900]] # if teff_ini < 5750: # teff_regions = [[3900,5700]] teff_regions = [[3800,5700]] feh_weights = ones(len(feh_space)) logg_weights = ones(len(logg_space)) ########################## ### Start the analysis ### ########################## ### Change directory to reduced/ os.chdir(file_path_reduced) #Change to ../reduced/ dir ### Load in spectra norm_spectrum = functions.read_ascii("norm_" + file_name + ".dat") norm_spectrum = functions.read_table(norm_spectrum) norm_spectrum = transpose(array(norm_spectrum)) flux_spectrum = functions.read_ascii("fluxcal_" + file_name + ".dat") flux_spectrum = functions.read_table(flux_spectrum) flux_spectrum = transpose(array(flux_spectrum)) flux_spectrum = spectype_functions.normalise(flux_spectrum,flux_normalise_w1,flux_normalise_w2) ### Find shift os.system("rm apshift*") ### Makesure keywpars is set at default iraf.unlearn(iraf.keywpars) iraf.filtpars.setParam("f_type","square",check=1,exact=1) iraf.filtpars.setParam("cuton",50,check=1,exact=1) iraf.filtpars.setParam("cutoff",2000,check=1,exact=1) os.system("cp "+model_path_norm+"fits_files/"+ini_template_spectrum+".fits .") run_fxcor("norm_"+ file_name,ini_template_spectrum+".fits","*","apshift",0,15,"gaussian","INDEF","INDEF") vel_shift = functions.read_ascii("apshift.txt") vel_shift = functions.read_table(vel_shift) vel_shift = vel_shift[0][11] if vel_shift == "INDEF": vel_shift = 0.0 if abs(vel_shift) > 1000.: vel_shift = 0.0 os.system("rm "+ini_template_spectrum+".fits") os.system("rm apshift*") print "Velocity shift of ",vel_shift ### Correct shift flux_wave = flux_spectrum[0] flux_flux = flux_spectrum[1] norm_wave = norm_spectrum[0] norm_flux = norm_spectrum[1] c = 3.0 * 10**5 norm_wave = norm_wave / ((vel_shift / c) + 1) ### Interpolate onto a 1A grid master_flux_wave = arange(3500,5900,1.) master_norm_wave = arange(4550,5900,1.) flux_interp = interpolate.splrep(flux_wave,flux_flux,s=0) flux_flux = interpolate.splev(master_flux_wave,flux_interp,der=0) norm_interp = interpolate.splrep(norm_wave,norm_flux,s=0) norm_flux = interpolate.splev(master_norm_wave,norm_interp,der=0) ###################################### ### Start Chi^2 array calculations ### ###################################### os.system("mkdir spectype_plots") #os.system("rm spectype_plots/" + object_name + "*.pdf") ################################# ### Read database into memory ### ################################# print "Reading database into memory" spec_database = [] normspec_database = [] teff_table_list = [] logg_table_list = [] feh_table_list = [] for teff in teff_space: print teff for logg in logg_space: for feh in feh_space: ### Read in spec template_spectrum = "template_" + str(teff) + "_" + str(logg) + "_" + str(feh)+".dat" #template_spectrum = functions.read_ascii(model_path_flux+template_spectrum) #template_spectrum = functions.read_table(template_spectrum) template_spectrum = loadtxt(model_path_flux+template_spectrum,comments='#') template_spectrum = transpose(array(template_spectrum)) template_spectrum = spectype_functions.normalise(template_spectrum,flux_normalise_w1,flux_normalise_w2) template_interp = interpolate.splrep(template_spectrum[0],template_spectrum[1],s=0) template_flux = interpolate.splev(master_flux_wave,template_interp,der=0) spec_database.append(template_flux) ### Read in normspec template_spectrum = "template_" + str(teff) + "_" + str(logg) + "_" + str(feh)+".dat" #template_spectrum = functions.read_ascii(model_path_norm+template_spectrum) #template_spectrum = functions.read_table(template_spectrum) template_spectrum = loadtxt(model_path_norm+template_spectrum,comments='#') template_spectrum = transpose(array(template_spectrum)) template_interp = interpolate.splrep(template_spectrum[0],template_spectrum[1],s=0) template_flux = interpolate.splev(master_norm_wave,template_interp,der=0) normspec_database.append(template_flux) teff_table_list.append(teff) logg_table_list.append(logg) feh_table_list.append(feh) master_weight = min(array(loop_input_spectrum(master_flux_wave,flux_flux,model_path_flux,teff_space,logg_space,feh_space,3900,5700,False,0,False))) master_weight = master_weight /2. print "Reference rms of ",master_weight ### >= F and <= M stars often get fitted with lower Fe/H, so we first fix Fe/H to ### get an idea of logg, before going through the usual routine. if teff_ini >= 5000 and ini_fix_feh == "true": ################################################################## ### Perform logg-weighted spectrum calculations - WITH FEH = 0 ### ################################################################## print "Calculating [Fe/H] fixed logg weighted rms" rms_logg = zeros(len(teff_table_list)) logg_regions_min = [] logg_regions_weights = [] count = 1 for region in logg_regions: w1 = region[0] w2 = region[1] if w1 <= 4000: to_normalise = False else: to_normalise = True if w1 < 3900 or master_weight > 1.0: shift_range = 0 else: shift_range = 10 if w1 < 4600: folder = model_path_flux input_wave = master_flux_wave input_spec = flux_flux else: folder = model_path_norm input_wave = master_norm_wave input_spec = norm_flux rms = array(loop_input_spectrum(input_wave,input_spec,folder,teff_space,logg_space,feh_space,w1,w2,to_normalise,shift_range,True)) i = find_min_index(rms) print teff_table_list[i],logg_table_list[i],feh_table_list[i],rms[i] #rms_logg = rms_logg + rms logg_regions_min.append(logg_table_list[i]) logg_regions_weights.append(min(rms)) rms_logg = rms_logg + (master_weight / min(rms))*rms count = count + 1 rms_logg = rms_logg / float(count) i = find_min_index(rms_logg) print teff_table_list[i],logg_table_list[i],0.0,rms_logg[i] #logg_min = logg_table_list[i] print logg_regions_min # if teff_ini >= 5750 and teff_ini < 6250: ### There should be no giants here, so choose the largest logg measurement # logg_min = max(logg_regions_min) # else: # logg_min = 1/array(logg_regions_weights) # logg_min = logg_min / sum(logg_min) # logg_min = sum(logg_min * array(logg_regions_min)) # #logg_min = average(logg_regions_min) logg_min = 1/array(logg_regions_weights) logg_min = logg_min / sum(logg_min) logg_min = sum(logg_min * array(logg_regions_min)) #logg_min = average(logg_regions_min) print "[Fe/H] Fixed Logg sensitive regions identify best fit of ",logg_min logg_min_index = (logg_min - min(logg_space))/0.5 for i in range(len(logg_weights)): logg_weights[i] = (abs(i - logg_min_index)/5.)+1. # rms_logg_table = transpose([teff_table_list,logg_table_list,feh_table_list,rms_logg]) # output_rms_table = open("temp_rms_table","w") # functions.write_table(rms_logg_table,output_rms_table) # output_rms_table.close() # plot_spectrum("temp_rms_table","fluxcal_"+file_name+".dat") # sys.exit() ###################################################################### ### Perform logg-weighted spectrum calculations - WITH FEH VARYING ### ###################################################################### print "Calculating logg weighted rms" rms_logg = zeros(len(teff_table_list)) logg_regions_min = [] logg_regions_weights = [] count = 1 for region in logg_regions: w1 = region[0] w2 = region[1] if w1 <= 4000: to_normalise = False else: to_normalise = True if w1 < 3900 or master_weight > 1.0: shift_range = 0 else: shift_range = 10 if w1 < 4600: folder = model_path_flux input_wave = master_flux_wave input_spec = flux_flux else: folder = model_path_norm input_wave = master_norm_wave input_spec = norm_flux rms = array(loop_input_spectrum(input_wave,input_spec,folder,teff_space,logg_space,feh_space,w1,w2,to_normalise,shift_range,False)) i = find_min_index(rms) print teff_table_list[i],logg_table_list[i],feh_table_list[i],rms[i] #rms_logg = rms_logg + rms logg_regions_min.append(logg_table_list[i]) logg_regions_weights.append(min(rms)) rms_logg = rms_logg + (master_weight / min(rms))*rms count = count + 1 rms_logg = rms_logg / float(count) i = find_min_index(rms_logg) print teff_table_list[i],logg_table_list[i],feh_table_list[i],rms_logg[i] #logg_min = logg_table_list[i] logg_min = 1/array(logg_regions_weights) logg_min = logg_min / sum(logg_min) logg_min = sum(logg_min * array(logg_regions_min)) print "Logg sensitive regions identify best fit of ",logg_min logg_min_index = int((logg_min - min(logg_space))/0.5) logg_weights = ones(len(logg_weights)) for i in range(len(logg_weights)): logg_weights[i] = (abs(i - logg_min_index)/10.)+1. # rms_logg_table = transpose([teff_table_list,logg_table_list,feh_table_list,rms_logg]) # output_rms_table = open("temp_rms_table","w") # functions.write_table(rms_logg_table,output_rms_table) # output_rms_table.close() # plot_spectrum("temp_rms_table","fluxcal_"+file_name+".dat") # sys.exit() ################################################## ### Perform feh-weighted spectrum calculations ### ################################################## print "Calculating feh weighted rms" rms_feh = zeros(len(teff_table_list)) count = 1 for region in feh_regions: w1 = region[0] w2 = region[1] if w1 < 4600: folder = model_path_flux input_wave = master_flux_wave input_spec = flux_flux else: folder = model_path_norm input_wave = master_norm_wave input_spec = norm_flux if w1 < 3900 or master_weight > 1.0: shift_range = 0 else: shift_range = 10 rms = array(loop_input_spectrum(input_wave,input_spec,folder,teff_space,logg_space,feh_space,w1,w2,True,shift_range,False)) i = find_min_index(rms) print teff_table_list[i],logg_table_list[i],feh_table_list[i],rms[i] #rms_feh = rms_feh + rms rms_feh = rms_feh + (master_weight / min(rms))*rms count = count + 1 rms_feh = rms_feh / float(count) i = find_min_index(rms_feh) print teff_table_list[i],logg_table_list[i],feh_table_list[i],rms_feh[i] feh_min = feh_table_list[i] feh_min_index = int((feh_min - min(feh_space))/0.5) for i in range(len(feh_weights)): feh_weights[i] = (abs(i - feh_min_index)/10.)+1. # rms_feh_table = transpose([teff_table_list,logg_table_list,feh_table_list,rms_feh]) # output_rms_table = open("temp_rms_table","w") # functions.write_table(rms_feh_table,output_rms_table) # output_rms_table.close() # plot_spectrum("temp_rms_table","fluxcal_"+file_name+".dat") ############################################################################### ### Calculate the corresponding chisq array for a range of reddening values ### ############################################################################### print "Calculating teff weighted rms" ### Change directory to reduced/deredden/ os.chdir(file_path_reduced + "deredden/") #Change to ../reduced/deredden dir ### Determine and create reddening loop os.system("ls *" + string.split(file_name,".")[0] + "*.dat > reddening_list") reddening_list = functions.read_ascii("reddening_list") os.system("rm reddening_list") os.system("rm ./*rms_table") reddening_values = [] reddening_rms = [] for flux_spectrum in reddening_list: reddening = float(string.split(flux_spectrum,"_")[1]) reddening_values.append(reddening) print "Trying reddening value E(B-V) = " + str(reddening) ### Load in flux spectrum of different reddening flux_spectrum = functions.read_ascii(flux_spectrum) flux_spectrum = functions.read_table(flux_spectrum) flux_spectrum = transpose(array(flux_spectrum)) flux_spectrum = spectype_functions.normalise(flux_spectrum,flux_normalise_w1,flux_normalise_w2) ### Correct shift flux_wave = flux_spectrum[0] flux_flux = flux_spectrum[1] c = 3.0 * 10**5 flux_wave = flux_wave / ((vel_shift / c) + 1) ### Interpolate onto a 1A grid flux_interp = interpolate.splrep(flux_wave,flux_flux,s=0) flux_flux = interpolate.splev(master_flux_wave,flux_interp,der=0) rms_teff = zeros(len(teff_table_list)) if master_weight > 1.0: shift_range = 0.0 else: shift_range = 10.0 if teff_ini > 6000: region_normalise = True if teff_ini <= 6000: region_normalise = False count = 1 for region in teff_regions: rms = array(loop_input_spectrum(master_flux_wave,flux_flux,model_path_flux,teff_space,logg_space,feh_space,region[0],region[1],region_normalise,shift_range,False)) rms = 0.6*rms + 0.2*rms_logg + 0.2*rms_feh #rms_teff = rms_teff + rms rms_teff = rms_teff + rms count = count+1 rms_teff = rms_teff / float(count) reddening_weight_factor = 0.5 ### Weight against reddening if reddening >= 0.0 and reddening <= max_reddening: reddening_weight = 1.0 if reddening > max_reddening: reddening_weight = (reddening - max_reddening)/reddening_weight_factor + 1 if reddening < 0.0: reddening_weight = abs(reddening)/reddening_weight_factor + 1 #reddening_weight = 1.0 rms_teff = rms_teff * reddening_weight i = find_min_index(rms_teff) print teff_table_list[i],logg_table_list[i],feh_table_list[i],rms_teff[i] rms_red_table = transpose([teff_table_list,logg_table_list,feh_table_list,rms_teff]) output_rms_table = open(str(reddening)+"_rms_table","w") functions.write_table(rms_red_table,output_rms_table) output_rms_table.close() reddening_rms.append(min(rms_teff)) ########################### ### Find best reddening ### ########################### for i in range(len(reddening_values)): if reddening_rms[i] == min(reddening_rms): best_reddening = reddening_values[i] break print "Best reddeining value of E(B-V):",best_reddening teff_min,logg_min,feh_min=plot_spectrum(str(best_reddening)+"_rms_table",reddening_list[i]) print object_name,teff_min,logg_min,feh_min os.system("rm ./*_rms_table") os.chdir(file_path_reduced) return teff_min,logg_min,feh_min
logg = 4.5 feh = 0.0 ### Read from param and config files model_path_flux = functions.read_param_file("MODEL_PATH_FLUX") model_path_norm = functions.read_param_file("MODEL_PATH_NORM") ########################## ### Plot FLUX spectrum ### ########################## flux_spectrum = "deredden_"+str(best_reddening)+"_"+file_name+".dat" flux_spectrum = functions.read_ascii(file_path + "reduced/deredden/" +flux_spectrum) flux_spectrum = functions.read_table(flux_spectrum) flux_spectrum = transpose(array(flux_spectrum)) flux_spectrum = spectype_functions.normalise(flux_spectrum,4400.,4600.) flux_wave = flux_spectrum[0] flux_flux = flux_spectrum[1] template_spectrum = "template_" + str(teff) + "_" + str(logg) + "_"+str(feh)+".dat" template_spectrum = functions.read_ascii(model_path_flux + template_spectrum) template_spectrum = functions.read_table(template_spectrum) template_spectrum = transpose(array(template_spectrum)) template_spectrum = spectype_functions.normalise(template_spectrum,4400.,4600.) template_wave = template_spectrum[0] template_flux = template_spectrum[1] plt.clf() plt.plot(template_wave,template_flux,"g-",label="synthetic")