from matplotlib import use use('Agg') from matplotlib.pylab import ioff ioff() data_directory = 'TRANK_nk_fit/' from TRANK import functionize_nk_file from matplotlib.pylab import * from numpy import loadtxt, array lamda_smooth = (loadtxt(data_directory+'fit_nk_fine.txt').T)[0] lamda_points = (loadtxt(data_directory+'fit_nk.txt').T)[0] fit_nk_f = functionize_nk_file(data_directory+'fit_nk.txt', skiprows = 0, kind = 'cubic') ## you can just load the file directly #actual_nk_f = functionize_nk_file('Au-glass_10nm_30p_effective_nk.txt', skiprows = 0, kind = 'cubic') # or use the setup file from basic_setup import nk_f_list, layer_index_of_fit actual_nk_f = nk_f_list[layer_index_of_fit] from matplotlib.pylab import figure, gca, subplots_adjust, tight_layout, show, savefig n_color = 'teal' k_color = 'orange' figure(figsize =(3.2,2.5), dpi = 220*2.0/3.0 ) nax = gca() kax = nax.twinx()
nlevels = (high - low) / base10delta + 1 levels = logspace(low, high, nlevels) return levels from TRANK import single_lamda_rms_error_map, functionize_nk_file, try_mkdir, find_min_indices_2d_array, extrap, rms_error_spectrum from numpy import ceil, floor, loadtxt if __name__ == '__main__': data_directory = 'TRANK_nk_fit/' map_direct = 'TRANK_error_maps/' from basic_setup import fit_nk_f, spectrum_list_generator, parameter_list_generator fit_nk_f = functionize_nk_file(data_directory + 'fit_nk_fine.txt', skiprows=0) lamda_list = loadtxt(data_directory + 'fit_nk.txt', unpack=True, usecols=[0]) lamda_fine = loadtxt(data_directory + 'fit_nk_fine.txt', unpack=True, usecols=[0]) rms_error_fine = rms_error_spectrum( lamda_list=lamda_fine, nk_f=fit_nk_f, spectrum_list_generator=spectrum_list_generator, parameter_list_generator=parameter_list_generator) rms_f = extrap(lamda_fine, rms_error_fine, kind='linear') try_mkdir(map_direct)
def thickness_fit(self, if_metal=False, set_list=None): time.sleep(1) show_plots = True data_directory = 'TRANK_nk_fit/' try_mkdir(data_directory) #if show_plots: # from matplotlib.pylab import show #use pyplot instead ###################### structure parameters #from basic_setup import fit_nk_f,spectrum_list_generator,parameter_list_generator try: test_setup = dyn_basic_setup(thickness=int(self.input_data[0]), R_line=self.input_data[1], R_dir=self.input_data[2], T_dir=self.input_data[3], if_metal=if_metal) except: self.Invalid_Input.emit() time.sleep(1) return #test_setup=dyn_basic_setup(thickness=int(self.input_data[0]),R_dir=self.input_data[2], # T_dir=self.input_data[3]) ########### #from os import getcwd, walk, listdir #from os.path import isfile #from numpy import arange, loadtxt, sqrt, mean, array if if_metal: dlamda_min = 1 else: dlamda_min = 4 #how to determine the dlamda dlamda_max = 50 lamda_max, lamda_min = test_setup.get_lamda_max_min() if self.lamda_list[0] != '': lamda_min = float(self.lamda_list[0]) if self.lamda_list[1] != '': lamda_max = float(self.lamda_list[1]) lamda_fine = arange(lamda_min, lamda_max + dlamda_min / 2.0, dlamda_min) passes = 0 max_rms_cutoff = 5.0 #percentage points net_rms_cutoff = 1.0 use_old_nk = False has_old_nk = False old_lamda = [] if self.nk_dir: #if isfile(data_directory+'fit_nk_fine.txt') and isfile(data_directory+'fit_nk.txt'): # fine has the complete set old_data = loadtxt(self.nk_dir).T #if self.old_data!=None: #print('Found local data.') self.TB1.append('Found local data.') #old_data = loadtxt( data_directory+'fit_nk.txt').T #fit_nk_f = functionize_nk_file(data_directory+'fit_nk.txt', skiprows = 0, kind = 'cubic') fit_nk_f = functionize_nk_file( self.nk_dir, skiprows=0, kind='cubic') #use the user-defined file old_lamda = old_data[0] has_old_nk = True if has_old_nk: rms_spectrum = rms_error_spectrum( lamda_list=lamda_fine, nk_f=fit_nk_f, spectrum_list_generator=None, parameter_list_generator=None, input_data=self.input_data, test_setup=test_setup ) # different way in using spectrum_lamda_error net_rms = sqrt(mean(array(rms_spectrum)**2)) * 100.0 max_rms = max(rms_spectrum) * 100.0 #print('nk found! RMS (max): %.2f (%.2f)'%(net_rms, max_rms)) self.TB1.append('nk found! RMS (max): %.2f (%.2f)' % (net_rms, max_rms)) ylim = max_rms_cutoff - (max_rms_cutoff / net_rms_cutoff) * net_rms if max_rms < ylim: use_old_nk = True passes = 2 #use_old_nk = False if use_old_nk == False: if not if_metal: def fit_nk_f(lamda): return 2.0 + 0.5j + 0.0 * lamda else: old_lamda = lamda_fine #from numpy.random import rand min_n, max_n = 0.0, 2.0 min_k, max_k = 0.0, 0.1 rand_n = random.rand(lamda_fine.size) * (max_n - min_n) + min_n rand_k = random.rand(lamda_fine.size) * (max_k - min_k) + min_k fit_nk_f = extrap_c(lamda_fine, rand_n + 1.0j * rand_k) def fit_nk_f(lamda): return 1.0 + 0.0 * lamda nk_plot(fit_nk_f, lamda_fine=lamda_fine, lamda_list=old_lamda, title_string='Initial nk', show_nodes=False, show_plots=show_plots, fig=self.fig) self.fig.canvas.draw() self.error_pages = [] self.nk_pages = [] #if show_plots: self.canvas.draw() #QCoreApplication.processEvents() # Force GUI to update inputs = dict( nk_f_guess=fit_nk_f, fig=self.fig, fig2=self.fig2, fig3=self.fig3, TB1=self.TB1, spectrum_list_generator=None, parameter_list_generator=None, lamda_min=lamda_min, lamda_max=lamda_max, dlamda_min=dlamda_min, dlamda_max=dlamda_max, max_passes=passes, delta_weight=0.02, tolerance=1e-5, interpolation_type='cubic', adaptation_threshold_max=0.05, adaptation_threshold_min=0.001, use_reducible_error=True, method='least_squares', KK_compliant=False, reuse_mode=use_old_nk, lamda_list=old_lamda, zero_weight_extra_pass=False, verbose=True, make_plots=True, show_plots=show_plots, #nk_spectrum_file_format = 'TRANK_nk_pass_%i.pdf', #rms_spectrum_file_format = 'rms_spectrum_pass_%i.pdf' , threads=cpu_count(), QCoreApplication=QCoreApplication, Gui_mode=1, if_e=self.if_e, input_data=self.input_data, test_setup=test_setup) if self.set_list: inputs.update( dict(tolerance=float(self.set_list[0]), adaptation_threshold_max=float(self.set_list[1]), adaptation_threshold_min=float(self.set_list[2]))) if not if_metal: delta_weight = 0.2 / dlamda_min inputs.update( dict(KK_compliant=True, delta_weight=delta_weight, k_weight_fraction=0.25, interpolation_type='linear', max_passes=2, Gui_mode=4, interpolate_to_fine_grid_at_end=False, reuse_mode=False)) error_pages, nk_pages, fit_nk_f, lamda_list = error_adaptive_iterative_fit_spectra( **inputs) self.error_pages += error_pages self.nk_pages += nk_pages self.Output_axes.emit((self.error_pages, self.nk_pages)) inputs.update( dict(nk_f_guess=fit_nk_f, lamda_list=lamda_list, KK_compliant=False, interpolation_type='cubic', max_passes=1, Gui_mode=1, interpolate_to_fine_grid_at_end=True)) error_pages, nk_pages = error_adaptive_iterative_fit_spectra(**inputs) self.error_pages += error_pages self.nk_pages += nk_pages self.Output_axes.emit((self.error_pages, self.nk_pages))
kind = 'cubic' #### air layer def nk_f_air(lamda): return 1.0+0.0j*lamda nk_f_list = [nk_f_air] #top working down thickness_list = [inf] coherency_list = ['i'] ##### film layers ###### film_thickness = 50 # nm #nk_f_list.append(functionize_nk_file('Au-glass_10nm_30p_effective_nk.txt',skiprows=1, kind = kind)) nk_f_list.append(functionize_nk_file('Mie_Au-glass_10nm_30p_effective_nk.txt',skiprows=1, kind = kind)) thickness_list.append(film_thickness) coherency_list.append('c') ###### substrate layer substrate_thickness = 2e-3 *(1e9) # 2 mm in nm nk_f_list.append(functionize_nk_file('Luke_Si3N4.txt',skiprows=1, kind = kind)) thickness_list.append(substrate_thickness) coherency_list.append('i') ##### back air layer #### nk_f_list.append(nk_f_air) thickness_list.append(inf) coherency_list.append('i') ###########
############## Structure Setup ############# nk_f_list = [nk_f_air] #top working down thickness_list = [inf] coherency_list = ['i'] ##### film layers ###### film_thickness = 25 # nm nk_f_list.append(nk_f_air) thickness_list.append(film_thickness) coherency_list.append('c') ###### substrate layer substrate_thickness = 520e-6 *(1e9) # 520 micons in nm nk_f_silica = functionize_nk_file('fused_silica_substrate.txt', skiprows = 2, kind = kind) nk_f_list.append(nk_f_silica) thickness_list.append(substrate_thickness) coherency_list.append('i') ##### back air layer #### nk_f_list.append(nk_f_air) thickness_list.append(inf) coherency_list.append('i') #### create the reversed lists coherency_list_r = list(reversed(coherency_list)) nk_f_list_r = list(reversed(nk_f_list)) thickness_list_r = list(reversed(thickness_list)) layer_index_of_fit_r = len(thickness_list)-layer_index_of_fit - 1
#### air layer def nk_f_air(lamda): return 1.0+0.0j*lamda def nk_f_glass(lamda): return 1.5+0.0j*lamda nk_f_list = [nk_f_air] #top working down thickness_list = [inf] coherency_list = ['i'] layer_index_of_fit = [1,3] ##### film layer 1 ###### film_thickness = 15 # nm nk_f_list.append(functionize_nk_file('Cu_Rakic_LD_nk.txt',skiprows=1, kind = 'cubic')) thickness_list.append(film_thickness) coherency_list.append('c') ###### substrate layer substrate_thickness = 2e-3 *(1e9) # 2 mm in nm nk_f_list.append(nk_f_glass) thickness_list.append(substrate_thickness) coherency_list.append('i') ##### film layer 1 ###### film_thickness = 5 # nm nk_f_list.append(functionize_nk_file('Cu_Rakic_LD_nk.txt',skiprows=1, kind = 'cubic')) thickness_list.append(film_thickness) coherency_list.append('c')
return 1.0 + 0.0j * lamda def nk_f_glass(lamda): return 1.5 + 0.0j * lamda nk_f_list = [nk_f_air] #top working down thickness_list = [inf] coherency_list = ['i'] ##### film layers ###### film_thickness = 15 # nm layer_index_of_fit = 1 nk_f_list.append( functionize_nk_file('Cu_Rakic_LD_nk.txt', skiprows=1, kind='cubic')) thickness_list.append(film_thickness) coherency_list.append('c') ###### substrate layer substrate_thickness = 2e-3 * (1e9) # 2 mm in nm nk_f_list.append(nk_f_glass) thickness_list.append(substrate_thickness) coherency_list.append('i') ##### back air layer #### nk_f_list.append(nk_f_air) thickness_list.append(inf) coherency_list.append('i') ###########