def template_fit(wave, flux, error, img_directory, sid): # Fit continuum fig = plt.figure() plt.plot(wave, flux) [cont_wave, cont_flux, cont_error] = extract_fit_part(wave, flux, error, 4040, 4060) [temp_wave, temp_flux, temp_error] = extract_fit_part(wave, flux, error, 5080, 5100) cont_wave = np.append(cont_wave, temp_wave) cont_flux = np.append(cont_flux, temp_flux) cont_error = np.append(cont_error, temp_error) cont_fitter = fitting.LevMarLSQFitter() cont = models.PowerLaw1D(cont_flux[0], cont_wave[0], - np.log(cont_flux[-1]/cont_flux[0]) / np.log(cont_wave[-1]/cont_wave[0]), fixed = {"x_0": True}) with warnings.catch_warnings(): warnings.filterwarnings('error') try: cont_fit = cont_fitter(cont, cont_wave, cont_flux, weights = cont_error, maxiter = 10000) except Exception: save_fig(fig, img_directory, str(sid) + "-cont-failed") plt.close() raise SpectraException("Continuum fit failed") plt.plot(wave, cont_fit(wave)) save_fig(fig, img_directory, str(sid) + "-cont-success") plt.close() # Fit emission lines flux = flux - cont_fit(wave) fig1 = plt.figure() plt.plot(wave, flux) hbeta_complex_fit_func = \ fe_temp_observed.FeII_template_obs(6.2, 2000.0, 2.6, 6.2, 2000.0, 2.6) + \ models.Gaussian1D(3.6, 4853.30, 40.0) + \ models.Gaussian1D(2.0, 4346.40, 2.0) + \ models.Gaussian1D(2.0, 4101.73, 2.0) + \ models.Gaussian1D(5.0, 4960.0, 6.0) + \ models.Gaussian1D(20.0, 5008.0, 6.0) fitter = fitting.LevMarLSQFitter() with warnings.catch_warnings(): warnings.filterwarnings('error') try: start = time.time() fit = fitter(hbeta_complex_fit_func, wave, flux, weights = error, maxiter = 3000) print("Time taken: ") print(time.time() - start) except Exception: save_fig(fig1, img_directory, str(sid) + "-failed") plt.close() raise SpectraException("Fit failed") expected = np.array(fit(wave)) plt.plot(wave, expected) save_fig(fig1, img_directory, str(sid) + "-succeed") plt.close() rcs = 0 for i in range(len(flux)): rcs = rcs + (flux[i] - expected[i]) ** 2.0 rcs = rcs / np.abs(len(flux)-17) if rcs > 10.0: raise SpectraException("Reduced chi-square too large: " + str(rcs)) return fit.parameters, cont_fit.parameters, rcs
def hbeta_complex_fit_2(wave, flux, error): os.chdir("../../") fig = plt.figure() plt.plot(wave, flux) [cont_wave, cont_flux, cont_error] = extract_fit_part(wave, flux, error, 4040, 4060) [temp_wave, temp_flux, temp_error] = extract_fit_part(wave, flux, error, 5080, 5100) cont_wave = np.append(cont_wave, temp_wave) cont_flux = np.append(cont_flux, temp_flux) cont_error = np.append(cont_error, temp_error) cont_fitter = fitting.LevMarLSQFitter() cont = models.PowerLaw1D(cont_flux[0], cont_wave[0], - np.log(cont_flux[-1]/cont_flux[0]) / np.log(cont_wave[-1]/cont_wave[0]), fixed = {"x_0": True}) cont_fit = cont_fitter(cont, cont_wave, cont_flux, weights = cont_error, maxiter = 10000) plt.plot(wave, cont_fit(wave)) plt.show() flux = flux - cont_fit(wave) plt.plot(wave, flux) hbeta_complex_fit_func = \ fe_temp_constructor.FeII_template(9900, 0, 1500.0, 4.0, 3.0, 3.0, 3.0, 1.0) fitter = fitting.LevMarLSQFitter() with warnings.catch_warnings(): warnings.filterwarnings('error') try: start = time.time() fit = fitter(hbeta_complex_fit_func, wave, flux, weights = error, maxiter = 3000) print(time.time() - start) except SpectraException: print(fit) print(fit.parameters) expected = np.array(fit(wave)) plt.plot(wave, expected) plt.show() fig.savefig("Hbeta-g-failed.jpg") plt.close() raise SpectraException("Line Hbeta fit failed") print(fit) print(fit.parameters) expected = np.array(fit(wave)) plt.plot(wave, expected) plt.show() fig.savefig("Hbeta-g.jpg") plt.close() rcs = 0 for i in range(len(flux)): rcs = rcs + (flux[i] - expected[i]) ** 2.0 rcs = rcs / np.abs(len(flux)-17) if rcs > 10.0: plt.close() raise SpectraException("Line Hbeta reduced chi-square too large" + str(rcs)) return fit.parameters, rcs
def mc_ee_single(rmid, mjd): print(" Begin for " + str(mjd)) try: [wave, flux, error] = read_raw_data(rmid, mjd) # error = pickle.load(open(Location.project_loca + "data/raw/" + # str(rmid) + "/" + str(mjd) + "/" + # "error_scaled.pkl", "rb")) [wave, flux, error] = mask_points(wave, flux, error) [wave, flux, error] = extract_fit_part(wave, flux, error, 4000.0, 5500.0) except Exception: print(" Unable to locate data file.") return [[], []] flux_with_noise = noise_gene(flux, error) error_with_noise = np.tile(error, [100, 1]) num_list = list(range(100)) m = Manager() p = Pool(processes=100) fit_res = m.list() func = partial(get_flux, wave, rmid, mjd, fit_res) args = list() for i in range(len(flux_with_noise)): args.append([flux_with_noise[i], error_with_noise[i], num_list[i]]) p.map(func, args) p.close() res = np.transpose(np.array(list(fit_res))) std_res = list() mean_res = list() for each in res: std_res.append(np.std(each)) mean_res.append(np.mean(each)) return [std_res, mean_res]
def main_process(sid, line): os.chdir("Fe2") try: os.mkdir(str(sid)) except OSError: pass os.chdir("../Fe2-fig") try: os.mkdir(str(sid)) except OSError: pass os.chdir("../") [wave, flux, fluxerr] = read_raw_data(sid) [wave, flux, fluxerr] = mask_points(wave, flux, fluxerr) # Extract the part of data for fitting [wave, flux, fluxerr] = extract_fit_part(wave, flux, fluxerr, line[0], line[2]) os.chdir("Fe2-fig/" + str(sid)) #try: [hbeta, bef, aft, o3sn, fesn] = compare_fe2(wave, flux, fluxerr) #except Exception as reason: # print(str(reason)) # exception_logging(sid, "Fe2", reason) # os.chdir("../../") # return os.chdir("../../") output_fit(hbeta, sid, "Hbeta") output_fit(bef, sid, "bef") output_fit(aft, sid, "aft") os.chdir("Fe2/") sn_file = open(str(sid) + ".txt", "a") sn_file.write("%9.4f %9.4f\n" % (o3sn, fesn)) sn_file.close() os.chdir("../") print(o3sn, fesn) print("Process finished for " + str(sid))
def compare_fe2(wave, flux, error): # First fit Hbeta and OIII se = False [wave_fit, flux_fit, error_fit] = extract_fit_part(wave, flux, error, 4000.0, 5500.0) #try: # [hbeta_g_res, g_rcs] = hbeta_complex_fit_2(wave_fit, flux_fit, error_fit) #except SpectraException: # se = True # g_rcs = 65535 #try: [hbeta_l_res, l_rcs] = hbeta_complex_fit_2(wave_fit, flux_fit, error_fit) #except SpectraException: # if se==True: # raise SpectraException("Fit for Hbeta complex failed") # else: # l_rcs = 65535 # pass #if g_rcs>l_rcs: # hbeta_res = hbeta_l_res # o3range = [(hbeta_l_res[13] - 2.0 * hbeta_l_res[14], hbeta_l_res[13] + 2.0 * hbeta_l_res[14])] # cont = lambda x: hbeta_l_res[18] * x + hbeta_l_res[19] # hbetarange = [(hbeta_l_res[1] - 2.0 * hbeta_l_res[2], hbeta_l_res[1] + 2.0 * hbeta_l_res[2])] #else: # hbeta_res = hbeta_g_res # o3range = [(hbeta_g_res[19] - 2.0 * hbeta_g_res[20], hbeta_g_res[19] + 2.0 * hbeta_g_res[20])] # cont = lambda x: hbeta_g_res[24] * x +hbeta_g_res[25] # hbetarange = union([(hbeta_g_res[1] - 2.0 * hbeta_g_res[2], hbeta_g_res[1] + 2.0 * hbeta_g_res[2]), # (hbeta_g_res[4] - 2.0 * hbeta_g_res[5], hbeta_g_res[4] + 2.0 * hbeta_g_res[5])]) #o3flux = flux_sum(o3range, wave, flux) - flux_sum(o3range, wave, list(map(cont, wave))) #hbetaflux = flux_sum(hbetarange, wave, flux) - flux_sum(hbetarange, wave, list(map(cont, wave))) #o3hb = o3flux / hbetaflux return [hbeta_l_res, 0, 0, 0, 0]
def rough_finder(sid, hbeta, o3, fe2): [wave, flux, ivar] = read_raw_data(sid) [wave, flux, ivar] = extract_fit_part(wave, flux, ivar, 4000, 5500) [wave, flux, ivar] = mask_points(wave, flux, ivar) try: [wave, flux, ivar, fig] = cont_handler(wave, flux, ivar) except Exception: fig.savefig("rough_finder/" + str(sid)) plt.close() return [-1, -1] fig.savefig("rough_finder/" + str(sid)) plt.close() try: i_hbeta = find_i(wave, flux, ivar, hbeta[0], hbeta[1]) i_o3 = find_i(wave, flux, ivar, o3[0], o3[1]) except ValueError: return [0, 0] i_fe2 = 0 for each in fe2: try: i_fe2 = i_fe2 + find_i(wave, flux, ivar, each[0], each[1]) except ValueError: continue o3vshbeta = i_o3 / i_hbeta fe2vshbeta = i_fe2 / i_hbeta return [o3vshbeta, fe2vshbeta]
def cont_handler(wave, flux, ivar): [cont_wave, cont_flux, cont_error] = extract_fit_part(wave, flux, ivar, 4040, 4060) [temp_wave, temp_flux, temp_error] = extract_fit_part(wave, flux, ivar, 5080, 5100) cont_wave = np.append(cont_wave, temp_wave) cont_flux = np.append(cont_flux, temp_flux) cont_error = np.append(cont_error, temp_error) cont_fitter = fitting.LevMarLSQFitter() with warnings.catch_warnings(): warnings.filterwarnings('error') cont = models.PowerLaw1D(cont_flux[0], cont_wave[0], - np.log(cont_flux[-1] / cont_flux[0]) / np.log(cont_wave[-1] / cont_wave[0]), fixed = {"x_0": True}) cont_fit = cont_fitter(cont, cont_wave, cont_flux, weights = cont_error, maxiter = 10000) fig = plt.figure() plt.plot(wave, flux) plt.plot(wave, cont_fit(wave)) flux_n = flux - cont_fit(wave) return [wave, flux_n, ivar, fig]
def main_process(sid): [wave, flux, error] = read_raw_data(str(sid)) [wave, flux, error] = mask_points(wave, flux, error) fit_res = read_fit_res(sid) [wave, flux, error] = extract_fit_part(wave, flux, error, fit_res[7] - 2.0 * fit_res[8], fit_res[7] + 2.0 * fit_res[8]) fwhm = calc_fwhm(wave, flux) std = fit_res[8] profile = fwhm / std print(sid + " " + str(profile)) return profile
def main_process(sid): print("Beginning process for " + str(sid)) # Read data and preprocessing [wave, flux, error] = read_raw_data(sid) [wave, flux, error] = mask_points(wave, flux, error) [wave, flux, error] = extract_fit_part(wave, flux, error, 4000.0, 5500.0) # Begin fitting and handling exception try: img_directory = "Fe2" [fit_res, cont_res, rcs] = template_fit(wave, flux, error, img_directory, sid) except SpectraException as reason: exception_logging(sid, reason) print("Failed\n\n") return output_fit(fit_res, sid, "Fe2") output_fit(cont_res, sid, "cont") print("Finished\n\n")
def fe_fitter_single(rmid, lock, rcs_dict, mjd): # Read data and preprocessing try: [wave, flux, error] = read_raw_data(rmid, mjd) [wave, flux, error] = mask_points(wave, flux, error) [wave, flux, error] = extract_fit_part(wave, flux, error, 4000.0, 5500.0) except Exception as reason: lock.acquire() exception_logging(rmid, mjd, reason) print("Failed for " + str(mjd)) lock.release() return os.chdir(Location.project_loca + "result/fit_with_temp/data") try: os.mkdir(str(rmid)) except OSError: pass os.chdir(Location.project_loca + "result/fit_with_temp/fig") try: os.mkdir(str(rmid)) except OSError: pass # Begin fitting and handling exception try: [fit_res, cont_res, rcs, numcont, numfit] = template_fit(wave, flux, error, True, [], rmid, mjd) except Exception as reason: lock.acquire() exception_logging(rmid, mjd, reason) print("Failed for " + str(mjd)) lock.release() return output_fit(fit_res, rmid, mjd, "Fe2") output_fit(cont_res, rmid, mjd, "cont") lock.acquire() rcs_dict[mjd] = rcs print("Finished for " + str(mjd)) lock.release()
def get_fwhm_hb(rmid, mjd): day_dir = Location.project_loca + "result/fit_with_temp/data/" + \ str(rmid) + "/" + str(mjd) + "-" hb_file = open(day_dir + "Fe2.pkl", "rb") hb = pickle.load(hb_file)[10:12] hb_file.close() cont_file = open(day_dir + "cont.pkl", "rb") cont = pickle.load(cont_file) cont_file.close() cont_func = models.PowerLaw1D(cont[0], cont[1], cont[2]) [wave, flux, error] = read_raw_data(rmid, mjd) [wave, flux, error] = extract_fit_part(wave, flux, error, hb[0] - 2.0 * hb[1], hb[0] + 2.0 * hb[1]) [wave, flux, error] = mask_points(wave, flux, error) flux = flux - cont_func(wave) up_wave = wave[0:flux.argmax()] up_flux = flux[0:flux.argmax()] down_flux = flux[flux.argmax():-1] down_wave = wave[flux.argmax():-1] wave_min = find_wave(up_wave, up_flux, 0.5 * np.amax(flux)) wave_max = find_wave(down_wave, down_flux, 0.5 * np.amax(flux)) return (wave_max - wave_min) / hb[1]
def template_fit(wave, flux, error, image_control, init_value, rmid, mjd): img_directory = Location.project_loca + "result/fit_with_temp/fig/" + \ str(rmid) # Fit continuum if image_control: # Control image output fig = plt.figure() plt.plot(wave, flux) # Part of the spectra without any prominent emission lines no_line_part = [[4000.0, 4050.0], [4150.0, 4280.0], [4420, 4750], [5050, 5500]] cont_wave = np.array([]) cont_flux = np.array([]) cont_error = np.array([]) for each_part in no_line_part: [pwave, pflux, perror] = extract_fit_part(wave, flux, error, each_part[0], each_part[1]) cont_wave = np.append(cont_wave, pwave) cont_flux = np.append(cont_flux, pflux) cont_error = np.append(cont_error, perror) cont_fitter = fitting.LevMarLSQFitter() if init_value == []: cont = fe_temp_observed.FeII_template_obs(0.0, 2000.0, 2.6, 0.0, 2000.0, 2.6, bounds = {"i_r_l1": [0.0, 50.0], "i_r_n3": [0.0, 50.0]}) + \ models.PowerLaw1D(flux[0], wave[0], - np.log(abs(flux[-1]/flux[0])+0.001) / np.log(abs(wave[-1]/wave[0]) + 0.001), fixed = {"x_0": True}) else: fe2_param = init_value[1][0:6] cont = fe_temp_observed.FeII_template_obs(fe2_param[0], fe2_param[1], fe2_param[2], fe2_param[3], fe2_param[4], fe2_param[5], bounds = {"i_r_l1": [0.0, 50.0], "i_r_n3": [0.0, 50.0]}) + \ models.PowerLaw1D(init_value[0][0], init_value[0][1], init_value[0][2], fixed = {"x_0": True}) with warnings.catch_warnings(): warnings.filterwarnings('error') try: cont_fit = cont_fitter(cont, cont_wave, cont_flux, weights = cont_error ** (-2), maxiter = 10000) except Exception as reason: if image_control: # Control image output save_fig(fig, img_directory, str(mjd) + "-cont-failed") plt.close() raise SpectraException("Continuum fit failed because of " + str(reason)) if image_control: # Control image output para = cont_fit.parameters[6:9] cont_cont = models.PowerLaw1D(para[0], para[1], para[2]) cont_spec = cont_cont(wave) fit_spec = cont_fit(wave) plt.plot(wave, fit_spec) plt.plot(wave, cont_spec) plt.plot(wave, fit_spec - cont_spec) save_fig(fig, img_directory, str(mjd) + "-cont-success") plt.close() # Fit emission lines flux = flux - cont_fit(wave) if image_control: # Control image output fig1 = plt.figure() plt.plot(wave, flux) if init_value == []: hbeta_complex_fit_func = \ models.Gaussian1D(3.6, 4853.30, 7.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4830, 4880], "stddev": [0.0001, 10.1]}) + \ models.Gaussian1D(3.6, 4853.30, 40.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4830, 4880], "stddev": [10.1, 500.0]}) + \ models.Gaussian1D(2.0, 4346.40, 2.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4323, 4369], "stddev": [0.0001, 50.0]}) + \ models.Gaussian1D(2.0, 4101.73, 2.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4078, 4125], "stddev": [0.0001, 50.0]}) + \ models.Gaussian1D(5.0, 4960.0, 6.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4937, 4983], "stddev": [0.0001, 23.8]}) + \ models.Gaussian1D(20.0, 5008.0, 6.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4985, 5031], "stddev": [0.0001, 23.8]}) else: hbetan_param = init_value[1][6:9] hbetab_param = init_value[1][9:12] hother_param = init_value[1][12:18] o3_param = init_value[1][18:24] hbeta_complex_fit_func = \ models.Gaussian1D(hbetan_param[0], hbetan_param[1], hbetan_param[2], bounds = {"amplitude": [0.0, 50.0], "mean": [4830, 4880], "stddev": [0.0001, 10.1]}) + \ models.Gaussian1D(hbetab_param[0], hbetab_param[1], hbetab_param[2], bounds = {"amplitude": [0.0, 50.0], "mean": [4830, 4880], "stddev": [10.1, 500.0]}) + \ models.Gaussian1D(hother_param[0], hother_param[1], hother_param[2], bounds = {"amplitude": [0.0, 50.0], "mean": [4323, 4369], "stddev": [0.0001, 50.0]}) + \ models.Gaussian1D(hother_param[3], hother_param[4], hother_param[5], bounds = {"amplitude": [0.0, 50.0], "mean": [4078, 4125], "stddev": [0.0001, 50.0]}) + \ models.Gaussian1D(o3_param[0], o3_param[1], o3_param[2], bounds = {"amplitude": [0.0, 50.0], "mean": [4937, 4983], "stddev": [0.0001, 23.8]}) + \ models.Gaussian1D(o3_param[3], o3_param[4], o3_param[5], bounds = {"amplitude": [0.0, 50.0], "mean": [4985, 5031], "stddev": [0.0001, 23.8]}) fitter = fitting.LevMarLSQFitter() with warnings.catch_warnings(): warnings.filterwarnings('error') try: fit = fitter(hbeta_complex_fit_func, wave, flux, weights = error ** (-2), maxiter = 3000) except Exception as reason: if image_control: # Control image output save_fig(fig1, img_directory, str(mjd) + "-failed") plt.close() raise SpectraException("Fit failed because of " + str(reason)) expected = np.array(fit(wave)) if image_control: # Control image output plt.plot(wave, expected) save_fig(fig1, img_directory, str(mjd) + "-succeed") plt.close() rcs = 0 for i in range(len(flux)): rcs = rcs + (flux[i] - expected[i]) ** 2.0 rcs = rcs / np.abs(len(flux)-23) if rcs > 10.0: raise SpectraException("Reduced chi-square too large: " + str(rcs)) return np.append(cont_fit.parameters[0:6], fit.parameters), cont_fit.parameters[6:9], rcs, cont_fitter.fit_info['nfev'], fitter.fit_info['nfev']
def template_fit(wave, flux, error, image_control, init_value, rmid, mjd): img_directory = Location.project_loca + "result/fit_with_temp/fig/" + \ str(rmid) # Fit continuum if image_control: # Control image output fig = plt.figure() plt.plot(wave, flux) # Part of the spectra without any prominent emission lines no_line_part = [[4000.0, 4050.0], [4150.0, 4280.0], [4420, 4750], [5050, 5500]] cont_wave = np.array([]) cont_flux = np.array([]) cont_error = np.array([]) for each_part in no_line_part: [pwave, pflux, perror] = extract_fit_part(wave, flux, error, each_part[0], each_part[1]) cont_wave = np.append(cont_wave, pwave) cont_flux = np.append(cont_flux, pflux) cont_error = np.append(cont_error, perror) cont_fitter = fitting.LevMarLSQFitter() if init_value == []: cont = fe_temp_observed.FeII_template_obs(0.0, 2000.0, 2.6, 0.0, 2000.0, 2.6, bounds = {"i_r_l1": [0.0, 50.0], "i_r_n3": [0.0, 50.0]}) + \ models.PowerLaw1D(flux[0], wave[0], - np.log(abs(flux[-1]/flux[0])+0.001) / np.log(abs(wave[-1]/wave[0]) + 0.001), fixed = {"x_0": True}) else: fe2_param = init_value[1][0:6] cont = fe_temp_observed.FeII_template_obs(fe2_param[0], fe2_param[1], fe2_param[2], fe2_param[3], fe2_param[4], fe2_param[5], bounds = {"i_r_l1": [0.0, 50.0], "i_r_n3": [0.0, 50.0]}) + \ models.PowerLaw1D(init_value[0][0], init_value[0][1], init_value[0][2], fixed = {"x_0": True}) with warnings.catch_warnings(): warnings.filterwarnings('error') try: cont_fit = cont_fitter(cont, cont_wave, cont_flux, weights=cont_error**(-2), maxiter=10000) except Exception as reason: if image_control: # Control image output save_fig(fig, img_directory, str(mjd) + "-cont-failed") plt.close() raise SpectraException("Continuum fit failed because of " + str(reason)) if image_control: # Control image output para = cont_fit.parameters[6:9] cont_cont = models.PowerLaw1D(para[0], para[1], para[2]) cont_spec = cont_cont(wave) fit_spec = cont_fit(wave) plt.plot(wave, fit_spec) plt.plot(wave, cont_spec) plt.plot(wave, fit_spec - cont_spec) save_fig(fig, img_directory, str(mjd) + "-cont-success") plt.close() # Fit emission lines flux = flux - cont_fit(wave) if image_control: # Control image output fig1 = plt.figure() plt.plot(wave, flux) if init_value == []: hbeta_complex_fit_func = \ models.Gaussian1D(3.6, 4853.30, 7.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4830, 4880], "stddev": [0.0001, 10.1]}) + \ models.Gaussian1D(3.6, 4853.30, 40.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4830, 4880], "stddev": [10.1, 500.0]}) + \ models.Gaussian1D(2.0, 4346.40, 2.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4323, 4369], "stddev": [0.0001, 50.0]}) + \ models.Gaussian1D(2.0, 4101.73, 2.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4078, 4125], "stddev": [0.0001, 50.0]}) + \ models.Gaussian1D(5.0, 4960.0, 6.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4937, 4983], "stddev": [0.0001, 23.8]}) + \ models.Gaussian1D(20.0, 5008.0, 6.0, bounds = {"amplitude": [0.0, 50.0], "mean": [4985, 5031], "stddev": [0.0001, 23.8]}) else: hbetan_param = init_value[1][6:9] hbetab_param = init_value[1][9:12] hother_param = init_value[1][12:18] o3_param = init_value[1][18:24] hbeta_complex_fit_func = \ models.Gaussian1D(hbetan_param[0], hbetan_param[1], hbetan_param[2], bounds = {"amplitude": [0.0, 50.0], "mean": [4830, 4880], "stddev": [0.0001, 10.1]}) + \ models.Gaussian1D(hbetab_param[0], hbetab_param[1], hbetab_param[2], bounds = {"amplitude": [0.0, 50.0], "mean": [4830, 4880], "stddev": [10.1, 500.0]}) + \ models.Gaussian1D(hother_param[0], hother_param[1], hother_param[2], bounds = {"amplitude": [0.0, 50.0], "mean": [4323, 4369], "stddev": [0.0001, 50.0]}) + \ models.Gaussian1D(hother_param[3], hother_param[4], hother_param[5], bounds = {"amplitude": [0.0, 50.0], "mean": [4078, 4125], "stddev": [0.0001, 50.0]}) + \ models.Gaussian1D(o3_param[0], o3_param[1], o3_param[2], bounds = {"amplitude": [0.0, 50.0], "mean": [4937, 4983], "stddev": [0.0001, 23.8]}) + \ models.Gaussian1D(o3_param[3], o3_param[4], o3_param[5], bounds = {"amplitude": [0.0, 50.0], "mean": [4985, 5031], "stddev": [0.0001, 23.8]}) fitter = fitting.LevMarLSQFitter() with warnings.catch_warnings(): warnings.filterwarnings('error') try: fit = fitter(hbeta_complex_fit_func, wave, flux, weights=error**(-2), maxiter=3000) except Exception as reason: if image_control: # Control image output save_fig(fig1, img_directory, str(mjd) + "-failed") plt.close() raise SpectraException("Fit failed because of " + str(reason)) expected = np.array(fit(wave)) if image_control: # Control image output plt.plot(wave, expected) save_fig(fig1, img_directory, str(mjd) + "-succeed") plt.close() rcs = 0 for i in range(len(flux)): rcs = rcs + (flux[i] - expected[i])**2.0 rcs = rcs / np.abs(len(flux) - 23) if rcs > 10.0: raise SpectraException("Reduced chi-square too large: " + str(rcs)) return np.append( cont_fit.parameters[0:6], fit.parameters), cont_fit.parameters[ 6:9], rcs, cont_fitter.fit_info['nfev'], fitter.fit_info['nfev']
def find_i(wave, flux, ivar, wavelength, width): [wave_i, flux_i, ivar_i] = extract_fit_part(wave, flux, ivar, wavelength - 0.5 * width, wavelength + 0.5 * width) i = max(flux_i) return i