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')
###########
