def find_equilibrium_concentration(params,
geom,
execline,
targets,
path='./',
funcparams=[0]):
'''
For a given set of parameters, this function simulates sputtering over a range of concentrations,
and identifies that concentration at which the sputter rate is exactly equal to the supply rate;
i.e., the steady concentration. Identifying this concentration is necessary for estimation of
parameters that appear in two-component systems.
'''
if (len(funcparams) == 3):
alpha = funcparams[0]
beta = funcparams[1]
gamma = funcparams[2]
for tt in targets:
params.target = tt
if (params.funcname and len(funcparams) == 3):
gm = gamma_max(tt[1][1], alpha, beta)
if gm <= 1.0:
gamma *= gm
params.cfunc = lambda depth: phistar_list(depth, tt[1][1], alpha,
beta, gamma)
ensure_data(params, geom, execline, path)
m0e_avgs = io.array_range(path, params, "target", targets, "m0e_avg")
n = 0 #find the intersection point, where the index [n] refers to the point after intersection, and at phi[n], a is less than b
if (m0e_avgs[n][0] > m0e_avgs[n][1]):
a = 0
b = 1
else:
a = 1
b = 0
while (m0e_avgs[n][a] > m0e_avgs[n][b]):
n += 1
#currently the above logic is only necessary to set up the while loop
#targets has form [ [["Ga", phi],["Sb", 1-phi]], etc ]
#for a certain range of phi. We can access these values directly through
#targets[n] --> [["Ga", phi], ["Sb", 1-phi]]
#targets[n][0][1]
phi0 = targets[n - 1][0][1]
phi1 = targets[n][0][1]
equilibrium_concentration = (phi1 *
(m0e_avgs[n - 1][a] - m0e_avgs[n - 1][b]) -
phi0 * (m0e_avgs[n][a] - m0e_avgs[n][b])) / (
m0e_avgs[n - 1][a] + m0e_avgs[n][b] -
m0e_avgs[n - 1][b] - m0e_avgs[n][a])
return equilibrium_concentration
def linked_PDE_coefficients_2D(wrapper, params, angles, finedeg, fitmethod=None, fitguess=None, path=None, dk=None):
'''
This function calculates *curved-target* estimates of the values of the coefficients
through second order in the linearized equation of motion. It provides the total
values of these coefficients, and also the contribution from each component (if
the target is a multi-component target).
TODO: FIGURE OUT EXACT METHOD USED, AND HOW THIS DIFFERS FROM LATER FUNCTION
TODO: Provide the *total* value within the zeroth entry field.
TODO: Also calculate the coefficient of the first-order hx term.
'''
oldpath = None
if path != None:
oldpath = os.getcwd()
os.chdir(path)
# run simulations if needed
params.k11 = 0 ; params.k22 = 0
for aa in angles:
params.angle = aa
wrapper.go(params)
params.angle = None
if dk:
params.k11 = dk; params.k22 = 0
for aa in angles:
params.angle = aa
wrapper.go(params)
params.k11 = -dk; params.k22 = 0
for aa in angles:
params.angle = aa
wrapper.go(params)
params.k11 = 0; params.k22 = dk
for aa in angles:
params.angle = aa
wrapper.go(params)
params.k11 = 0; params.k22 = -dk
for aa in angles:
params.angle = aa
wrapper.go(params)
params.k11 = 0; params.k22 = 0
# determine number of species, and number of impacts
species = len(params.target)
impacts = params.impacts
# allocate storage
results_list = []
totals = dict()
results_list.append(totals)
for kk in range(species):
# storage for returned values
rvals = dict()
rvals["angles"] = angles
rvals["finedeg"] = finedeg
# functions we will use for fitting
fitfuncD0 = pyam.poly_yamamura
fitfuncD1 = pyam.poly_yamamura_derivative
# setup the FitMethod
evenopts = {"symmetry":"even", "coeff_list":['A', 'B', 'C']}
oddopts = {"symmetry":"odd" , "coeff_list":['A', 'B', 'C']}
fitnames = ["A", "B", "C"]
fitguess = [1.0, 0.0, 0.0]
evenfit = fittools.FitMethod( pyam.poly_yamamura, fitnames, evenopts, pyam.poly_yamamura_cerror )
oddfit = fittools.FitMethod( pyam.poly_yamamura, fitnames, oddopts, pyam.poly_yamamura_cerror )
# storage for nodelist
nodelist = []
# M0e data
m0e_avg = io.array_range( './', params, 'angle', angles, 'm0e_avg' )
m0e_std = io.array_range( './', params, 'angle', angles, 'm0e_std' )
m0e_vals = np.array( [ a[kk] for a in m0e_avg ] )
m0e_errs = np.array( [ b[kk]/np.sqrt(params.impacts) * 1.97 for b in m0e_std ] )
m0e_node = evenfit.CreateFitNode( list(fitguess), angles, m0e_vals, m0e_errs )
rvals["m0e_avg"] = m0e_vals
rvals["m0e_err"] = m0e_errs
nodelist.append(m0e_node)
# M1e data
m1e_avg = io.array_range( './', params, 'angle', angles, 'm1e_avg' )
m1e_std = io.array_range( './', params, 'angle', angles, 'm1e_std' )
m1e_vals = np.array( [ a[kk][0] for a in m1e_avg ] )
m1e_errs = np.array( [ b[kk][0]/np.sqrt(params.impacts) * 1.97 for b in m1e_std ] )
m1e_node = oddfit.CreateFitNode( list(fitguess), angles, m1e_vals, m1e_errs )
rvals["m1e_avg"] = m1e_vals
rvals["m1e_err"] = m1e_errs
nodelist.append(m1e_node)
# M1r data
m1r_avg = io.array_range( './', params, 'angle', angles, 'm1r_avg' )
m1r_std = io.array_range( './', params, 'angle', angles, 'm1r_std' )
m1r_vals = np.array( [ a[kk][0] for a in m1r_avg ] )
m1r_errs = np.array( [ b[kk][0]/np.sqrt(params.impacts) * 1.97 for b in m1r_std ] )
m1r_node = oddfit.CreateFitNode( list(fitguess), angles, m1r_vals, m1r_errs )
rvals["m1r_avg"] = m1r_vals
rvals["m1r_err"] = m1r_errs
nodelist.append(m1r_node)
if (dk):
rvals["dk"] = dk
# K11+
params.k11 = dk; params.k22 = 0
m0ek1p_avg = io.array_range( './', params, 'angle', angles, 'm0e_avg' )
m0ek1p_std = io.array_range( './', params, 'angle', angles, 'm0e_std' )
m0ek1p_vals = np.array( [ a[kk] for a in m0ek1p_avg ] )
m0ek1p_errs = np.array( [ b[kk]/np.sqrt(params.impacts) * 1.97 for b in m0ek1p_std ] )
m0ek1p_node = evenfit.CreateFitNode( list(fitguess), angles, m0ek1p_vals, m0ek1p_errs )
rvals["m0ek1p_avg"] = m0ek1p_vals
rvals["m0ek1p_err"] = m0ek1p_errs
nodelist.append(m0ek1p_node)
# K11-
params.k11 = -dk; params.k22 = 0
m0ek1m_avg = io.array_range( './', params, 'angle', angles, 'm0e_avg' )
m0ek1m_std = io.array_range( './', params, 'angle', angles, 'm0e_std' )
m0ek1m_vals = np.array( [ a[kk] for a in m0ek1m_avg ] )
m0ek1m_errs = np.array( [ b[kk]/np.sqrt(params.impacts) * 1.97 for b in m0ek1m_std ] )
m0ek1m_node = evenfit.CreateFitNode( list(fitguess), angles, m0ek1m_vals, m0ek1m_errs )
rvals["m0ek1m_avg"] = m0ek1m_vals
rvals["m0ek1m_err"] = m0ek1m_errs
nodelist.append(m0ek1m_node)
# K22+
params.k11 = 0; params.k22 = dk
m0ek2p_avg = io.array_range( './', params, 'angle', angles, 'm0e_avg' )
m0ek2p_std = io.array_range( './', params, 'angle', angles, 'm0e_std' )
m0ek2p_vals = np.array( [ a[kk] for a in m0ek2p_avg ] )
m0ek2p_errs = np.array( [ b[kk]/np.sqrt(params.impacts) * 1.97 for b in m0ek2p_std ] )
m0ek2p_node = evenfit.CreateFitNode( list(fitguess), angles, m0ek2p_vals, m0ek2p_errs )
rvals["m0ek2p_avg"] = m0ek2p_vals
rvals["m0ek2p_err"] = m0ek2p_errs
nodelist.append(m0ek2p_node)
# K22-
params.k11 = 0; params.k22 = -dk
m0ek2m_avg = io.array_range( './', params, 'angle', angles, 'm0e_avg' )
m0ek2m_std = io.array_range( './', params, 'angle', angles, 'm0e_std' )
m0ek2m_vals = np.array( [ a[kk] for a in m0ek2m_avg ] )
m0ek2m_errs = np.array( [ b[kk]/np.sqrt(params.impacts) * 1.97 for b in m0ek2m_std ] )
m0ek2m_node = evenfit.CreateFitNode( list(fitguess), angles, m0ek2m_vals, m0ek2m_errs )
rvals["m0ek2m_avg"] = m0ek2m_vals
rvals["m0ek2m_err"] = m0ek2m_errs
nodelist.append(m0ek2m_node)
params.k11 = 0; params.k22 = 0
# SuperNode and Fitting
superfit = fittools.FitSuperNode("p", [0.5], nodelist)
fits, err = superfit.fit_data()
m0e_fit = fits[0]
m1e_fit = fits[1]
m1r_fit = fits[2]
#finedeg = np.linspace(0,90,91)
finerad = finedeg * np.pi / 180.
# record fitted values of the functions, themselves
rvals["m0e_vals"] = fitfuncD0(m0e_fit, finedeg, evenopts)
rvals["m1e_vals"] = fitfuncD0(m1e_fit, finedeg, oddopts)
rvals["m1r_vals"] = fitfuncD0(m1r_fit, finedeg, oddopts)
rvals["m1_vals"] = rvals["m1e_vals"] + rvals["m1r_vals"]
# record fitted values of the derivatives of M1
rvals["m1ep_vals"] = fitfuncD1( m1e_fit, finedeg, oddopts )
rvals["m1rp_vals"] = fitfuncD1( m1r_fit, finedeg, oddopts )
rvals["m1p_vals"] = rvals["m1ep_vals"] + rvals["m1rp_vals"]
# construct SX
rvals["sxe_coeffs"] = np.cos(finerad) * rvals["m1ep_vals"] - np.sin(finerad) * rvals["m1e_vals"]
rvals["sxr_coeffs"] = np.cos(finerad) * rvals["m1rp_vals"] - np.sin(finerad) * rvals["m1r_vals"]
rvals["sxc_coeffs_approx"] = - np.cos(finerad) * rvals["m1ep_vals"] / 2.0
rvals["sx_coeffs"] = rvals["sxe_coeffs"] + rvals["sxr_coeffs"]
# construct SY
rvals["sye_coeffs"] = np.cos(finerad)**2 / np.sin(finerad) * rvals["m1e_vals"]
rvals["syr_coeffs"] = np.cos(finerad)**2 / np.sin(finerad) * rvals["m1r_vals"]
rvals["syc_coeffs_approx"] = - np.cos(finerad)**2 / np.sin(finerad) * rvals["m1e_vals"] / 2.0
rvals["sy_coeffs"] = rvals["sye_coeffs"] + rvals["syr_coeffs"]
if dk:
k1p_fit = fits[3]
k1m_fit = fits[4]
k2p_fit = fits[5]
k2m_fit = fits[6]
print m0e_fit
print m1e_fit
print m1r_fit
print k1p_fit
print k1m_fit
print k2p_fit
print k2m_fit
# record fitted values of the functions, themselves
rvals["m0ek1p_vals"] = fitfuncD0(k1p_fit, finedeg, evenopts)
rvals["m0ek1m_vals"] = fitfuncD0(k1m_fit, finedeg, evenopts)
rvals["m0ek2p_vals"] = fitfuncD0(k2p_fit, finedeg, evenopts)
rvals["m0ek2m_vals"] = fitfuncD0(k2m_fit, finedeg, evenopts)
# construct corrections to SX, SY
rvals["sxc_coeffs"] = - np.cos(finerad) * ( rvals["m0ek1p_vals"] - rvals["m0ek1m_vals"] ) / (2.0*dk)
rvals["syc_coeffs"] = - np.cos(finerad) * ( rvals["m0ek2p_vals"] - rvals["m0ek2m_vals"] ) / (2.0*dk)
rvals["sx_coeffs"] += rvals["sxc_coeffs"]
rvals["sy_coeffs"] += rvals["syc_coeffs"]
results_list.append(rvals)
if oldpath != None:
os.chdir(oldpath)
# construct the sum dictionary
return results_list
def fit_moments_1D(params, angles, fitmethod=None, fitguess=None, path='./'):
'''
This function takes a set of parametric dependencies and a *range of angles,*
and fits the zeroth, first erosive, and first redistributive moments over
those angles to a Yamamura-modified polynomial.
The function also stores the fits to a file at the end of the function, and
checks for the existence of that file at the beginning of the function. This
allows scripts to be re-run during testing without re-calculating the fits.
However, it may be that this function is not the best place for this
functionality.
In principle different fit methods can be provided, but this is not currently
implemented.
'''
# see if fit values already exist
fname = params.fname(['target', 'beam', 'energy'])
if os.path.isfile('%s.momfits' % (fname)):
f = shelve.open('%s.momfits' % (fname))
results_list = list(f['results_list'])
f.close()
return results_list
# determine number of species, and number of impacts
species = len(params.target)
impacts = params.impacts
finedeg = np.linspace(0,90,91)
# configure storage for pure or mutli-species results
extra_species = 0
if species > 1: extra_species = 1
total_species = species + extra_species
# load moment data
m0e_avg = -np.array( io.array_range( './', params, 'angle', angles, 'evdM0_avg' ))
m0e_std = np.array( io.array_range( './', params, 'angle', angles, 'evdM0_std' ))
m1e_avg = -np.array( io.array_range( './', params, 'angle', angles, 'evdM1_avg' ))
m1e_std = np.array( io.array_range( './', params, 'angle', angles, 'evdM1_std' ))
m1r_avg = np.array(io.array_range( './', params, 'angle', angles, 'rddM1_avg' ))
m1r_std = np.array(io.array_range( './', params, 'angle', angles, 'rddM1_std' ))
# create even fit parameter
fp_even = lmf.Parameters()
fp_even.add("p" , value=0.25, min=0.0)
fp_even.add("c0", value=0.00)
fp_even.add("c2", value=0.00)
fp_even.add("c4", value=0.00)
# create odd fit parameter
fp_odd = lmf.Parameters()
fp_odd.add("p" , value=0.25, min=0.0)
fp_odd.add("c1", value=0.00)
fp_odd.add("c3", value=0.00)
fp_odd.add("c5", value=0.00)
# greate a global fit parameter
fp_global = lmf.Parameters()
fp_global.add("p", value=0.25, min=0.0)
# allocate storage
results_list = []
# iterate through species
for kk in range(total_species):
# storage for returned values
rvals = dict()
rvals["angles"] = angles
rvals["finedeg"] = finedeg
# storage for nodelist
nodelist = []
# M0e data
m0e_vals = np.array( [ a[kk] for a in m0e_avg ] )
m0e_errs = np.array( [ b[kk]/np.sqrt(params.impacts) * 1.97 for b in m0e_std ] )
rvals["m0e_dats"] = m0e_vals
rvals["m0e_errs"] = m0e_errs
m0e_node = fitter.FitNode( copy.deepcopy(fp_even), pyam.poly_yamamura_1D, angles, m0e_vals, m0e_errs )
nodelist.append(m0e_node)
# M1e data
m1e_vals = np.array( [ a[kk][0] for a in m1e_avg ] )
m1e_errs = np.array( [ b[kk][0]/np.sqrt(params.impacts) * 1.97 for b in m1e_std ] )
rvals["m1e_dats"] = m1e_vals
rvals["m1e_errs"] = m1e_errs
m1e_node = fitter.FitNode( copy.deepcopy(fp_odd), pyam.poly_yamamura_1D, angles, m1e_vals, m1e_errs )
nodelist.append(m1e_node)
# M1r data
m1r_vals = np.array( [ a[kk][0] for a in m1r_avg ] )
m1r_errs = np.array( [ b[kk][0]/np.sqrt(params.impacts) * 1.97 for b in m1r_std ] )
rvals["m1r_dats"] = m1r_vals
rvals["m1r_errs"] = m1r_errs
m1r_node = fitter.FitNode( copy.deepcopy(fp_odd), pyam.poly_yamamura_1D, angles, m1r_vals, m1r_errs )
nodelist.append(m1r_node)
# SuperNode and Fitting
snode = fitter.FitSuperNode(nodelist, fp_global)
result = snode.fit()
fparams = result.params
rvals['m0e_fit'] = m0e_node.result.params
rvals['m1e_fit'] = m1e_node.result.params
rvals['m1r_fit'] = m1r_node.result.params
results_list.append(rvals)
# populate a shelf
fname = params.fname(['target', 'beam', 'energy'])
f = shelve.open('%s.momfits' % (fname))
f['results_list'] = results_list
f.close()
return results_list
def calculate_PDE_coefficients(wrapper, params, angles, fitmethod, guess, finedeg=None, path='./', curvature_effects_dk=None):
'''
This function performs most of the angle-dependent fitting and differenting needed to
estimate values of coefficients in PDE terms. The user must supply
- a BCA_wrapper for running the simulations.
- a params object, in which everything is specified except the angles
- a list of angles to use in fitting
- a FitMethod object
- a guess at paramters
OPTIONAL
- a fine mesh on which to return fits and their derivatives (defaults to linspace(0,90,91))
- path to the data files (defaults to './')
'''
# set up fine degree mesh and fine radian mesh
if finedeg==None:
finedeg = np.linspace(0,90,91) ;
finerad = finedeg * np.pi / 180.0
# identify number of species
species = len(params.target)
# if the files are not already present, then run the simulations
for aa in angles:
params.angle = aa; wrapper.go(params)
if (curvature_effects_dk):
dk = curvature_effects_dk
params.k22 = 0.0
params.k11 = dk; wrapper.go(params);
params.k11 = -dk; wrapper.go(params);
params.k11 = 0.0
params.k22 = dk; wrapper.go(params);
params.k22 = -dk; wrapper.go(params);
params.k22 = 0.0
# array for number of impacts
impacts = np.array( io.array_range(path, params, "angle", angles, "impacts") )
# now, a really big loop, to generate fits on the moments and coefficients for all species
species_list = []
for kk in range(species):
#m1e_dats = np.array( m1e_avg[:,kk,1] )
#m1e_errs = np.array( m1e_err[:,kk,1] )
#m1r_dats = np.array( m1r_avg[:,kk,1] )
#m1r_errs = np.array( m1r_err[:,kk,1] )
rvals = dict()
# extract the data for m1e (values, uncertainty), and try to fit it with the poly_yamamura() function
fitmethod.params["symmetry"] = "even"
m0e_avg = np.array( io.array_range(path, params, "angle", angles, "m0e_avg") )
m0e_std = np.array( io.array_range(path, params, "angle", angles, "m0e_std") )
m0e_err = np.array( [a / np.sqrt(b) * 1.97 for a,b in zip(m0e_std,impacts)] )
m0e_fit = fitmethod.fit_data( guess, angles, np.array( m0e_avg[:,kk] ), stderrs=np.array( m0e_err[:,kk] ) )
rvals["m0e_avg"] = m0e_avg[:,kk]
rvals["m0e_err"] = m0e_err[:,kk]
rvals["m0e_vals"] = fitmethod.eval_function( m0e_fit, finedeg )
# extract the data for m1e (values, uncertainty), and try to fit it with the poly_yamamura() function
fitmethod.params["symmetry"] = "odd"
m1e_avg = np.array( io.array_range(path, params, "angle", angles, "m1e_avg") )
m1e_std = np.array( io.array_range(path, params, "angle", angles, "m1e_std") )
m1e_err = np.array( [a / np.sqrt(b) * 1.97 for a,b in zip(m1e_std,impacts)] )
m1e_fit = fitmethod.fit_data( guess, angles, np.array( m1e_avg[:,kk,1] ), stderrs=np.array( m1e_err[:,kk,1] ) )
rvals["m1e_avg"] = m1e_avg[:,kk,1]
rvals["m1e_err"] = m1e_err[:,kk,1]
rvals["m1e_vals"] = fitmethod.eval_function( m1e_fit, finedeg )
# extract the data for m1r (values, uncertainty), and try to fit it with the poly_yamamura() function
m1r_avg = np.array( io.array_range(path, params, "angle", angles, "m1r_avg") )
m1r_std = np.array( io.array_range(path, params, "angle", angles, "m1r_std") )
m1r_err = np.array( [a / np.sqrt(b) * 1.97 for a,b in zip(m1r_std,impacts)] )
m1r_fit = fitmethod.fit_data( guess, angles, np.array( m1r_avg[:,kk,1] ), stderrs=np.array( m1r_err[:,kk,1] ) )
rvals["m1r_avg"] = m1r_avg[:,kk,1]
rvals["m1r_err"] = m1r_err[:,kk,1]
rvals["m1r_vals"] = fitmethod.eval_function( m1r_fit, finedeg )
rvals["m1_vals"] = rvals["m1e_vals"] + rvals["m1r_vals"]
rvals["m1ep_vals"] = fitmethod.eval_derivative( m1e_fit, finedeg )
rvals["m1rp_vals"] = fitmethod.eval_derivative( m1r_fit, finedeg )
rvals["m1p_vals"] = rvals["m1ep_vals"] + rvals["m1rp_vals"]
rvals["sxe_coeffs"] = cos(finerad) * rvals["m1ep_vals"] - sin(finerad) * rvals["m1e_vals"]
rvals["sxr_coeffs"] = cos(finerad) * rvals["m1rp_vals"] - sin(finerad) * rvals["m1r_vals"]
rvals["sx_coeffs"] = rvals["sxe_coeffs"] + rvals["sxr_coeffs"]
rvals["sye_coeffs"] = cos(finerad)**2 / sin(finerad) * rvals["m1e_vals"]
rvals["syr_coeffs"] = cos(finerad)**2 / sin(finerad) * rvals["m1r_vals"]
rvals["sy_coeffs"] = rvals["sye_coeffs"] + rvals["syr_coeffs"]
if (curvature_effects_dk):
dk = curvature_effects_dk
fitmethod.params["symmetry"] = "even"
params.k22 = 0.0
params.k11 = dk;
m0e_avg = np.array( io.array_range(path, params, "angle", angles, "m0e_avg") )
m0e_std = np.array( io.array_range(path, params, "angle", angles, "m0e_std") )
m0e_err = np.array( [a / np.sqrt(b) * 1.97 for a,b in zip(m0e_std,impacts)] )
m0e_fit = fitmethod.fit_data( guess, angles, np.array( m0e_avg[:,kk] ), stderrs=np.array( m0e_err[:,kk] ) )
k11p = fitmethod.eval_function( m0e_fit, finedeg )
rvals["m0ek1p_avg"] = m0e_avg[:,kk] ;
rvals["m0ek1p_err"] = m0e_err[:,kk] ;
rvals["m0ek1p_vals"] = k11p
params.k11 = -dk
m0e_avg = np.array( io.array_range(path, params, "angle", angles, "m0e_avg") )
m0e_std = np.array( io.array_range(path, params, "angle", angles, "m0e_std") )
m0e_err = np.array( [a / np.sqrt(b) * 1.97 for a,b in zip(m0e_std,impacts)] )
m0e_fit = fitmethod.fit_data( guess, angles, np.array( m0e_avg[:,kk] ), stderrs=np.array( m0e_err[:,kk] ) )
k11m = fitmethod.eval_function( m0e_fit, finedeg )
rvals["m0ek1m_avg"] = m0e_avg[:,kk]
rvals["m0ek1m_err"] = m0e_err[:,kk]
rvals["m0ek1m_vals"] = k11m
params.k11 = 0.0
params.k11 = 0.0
params.k22 = dk
m0e_avg = np.array( io.array_range(path, params, "angle", angles, "m0e_avg") )
m0e_std = np.array( io.array_range(path, params, "angle", angles, "m0e_std") )
m0e_err = np.array( [a / np.sqrt(b) * 1.97 for a,b in zip(m0e_std,impacts)] )
m0e_fit = fitmethod.fit_data( guess, angles, np.array( m0e_avg[:,kk] ), stderrs=np.array( m0e_err[:,kk] ) )
k22p = fitmethod.eval_function( m0e_fit, finedeg )
rvals["m0ek2p_avg"] = m0e_avg[:,kk]
rvals["m0ek2p_err"] = m0e_err[:,kk]
rvals["m0ek2p_vals"] = k22p
params.k22 = -dk
m0e_avg = np.array( io.array_range(path, params, "angle", angles, "m0e_avg") )
m0e_std = np.array( io.array_range(path, params, "angle", angles, "m0e_std") )
m0e_err = np.array( [a / np.sqrt(b) * 1.97 for a,b in zip(m0e_std,impacts)] )
m0e_fit = fitmethod.fit_data( guess, angles, np.array( m0e_avg[:,kk] ), stderrs=np.array( m0e_err[:,kk] ) )
k22m = fitmethod.eval_function( m0e_fit, finedeg )
rvals["m0ek2m_avg"] = m0e_avg[:,kk]
rvals["m0ek2m_err"] = m0e_err[:,kk]
rvals["m0ek2m_vals"] = k22m
params.k22 = 0.0
fitmethod.params["symmetry"] = "odd"
rvals["sxe_curvcorr"] = (k11p - k11m) / (2*dk) * np.cos(finerad)
rvals["sye_curvcorr"] = (k22p - k22m) / (2*dk) * np.cos(finerad)
#rvals["sxe_curvcorr"] = (k11p - rvals["m0e_vals"]) / (dk) * np.cos(finerad)
#rvals["sye_curvcorr"] = (k22p - rvals["m0e_vals"]) / (dk) * np.cos(finerad)
rvals["sx_coeffs"] += rvals["sxe_curvcorr"]
rvals["sy_coeffs"] += rvals["sye_curvcorr"]
species_list.append(rvals)
return species_list
#basic parameter setup
params.target = [["Si", 1.0]]
params.beam = "Ar"
params.energy = 250
params.impacts = 300
params.angle = None
# do the simulations
angles = np.linspace(0, 80, 9)
for aa in angles:
print "running angle %d" % (aa)
params.angle = aa
wrapper.go(params)
finedeg = np.linspace(0, 90, 91)
params.angle = None
fits = help.linked_PDE_coefficients_1D(wrapper, params, angles, finedeg)
myplot = help.plot_single_flat_angle_dependence_summary(fits[0])
plt.show()
exit()
# plot graph of M0
m0e_avg = io.array_range('./', params, 'angle', angles, 'evdM0_avg')
m0e_std = io.array_range('./', params, 'angle', angles, 'evdM0_std')
yval = [a[0] for a in m0e_avg]
yerr = [b[0] / np.sqrt(params.impacts) * 1.97 for b in m0e_std]
plt.figure(1)
plt.errorbar(angles, yval, yerr=yerr, label='m0e')
plt.show()
plt.savefig('%s.svg' % (params.fname()))
def tri3dst_write_input (path, environment_parameters, tri3dst_parameters): #meant to take a parameter object
#if (isinstance(environment_parameters.shape, basestring) == True):
# parameters.shape = shapedict[parameters.shape]
params = environment_parameters
extras = params.additional_parameters
# build target based on ion energy
geom = Geometry()
energy = params.energy
geom.set_attr([energy, energy, energy], [2*energy, 2*energy, 2*energy])
fname = params.fname() + '.in'
f = open(fname, 'w')
# THIS CODE IS FOR THE VERSION WOLFHARD E-MAILED TO ME ON 2014-07-25
f.write("%s automatically generated file\n" % (params.runid()) )
f.write('%d %d %d %.2f 12345\n' % (params.impacts, len(params.target)+1, extras["shape"], extras["film_thickness"]) )
f.write('1 3 1 0 0. 0 0 0 3\n') #ask professor norris about these x-z atomic density averages
f.write('%d %d %d -1 -1\n' % (geom.xbound, geom.ybound, geom.zbound)) #these are 400Å xyz geometries and open (not periodic) boundaries
f.write('%d %d %d %.5f %.5f\n' % (geom.x, geom.y, geom.z, params.k11, params.k22) )
f.write('100 1 1 1 1 1 0 0 0 0 0 0 0 0 0\n') #output control.
f.write('-1 -1 1 5 0 0 0 0\n') #listed as diagnostic parameters
# read standard values of various quantities for many elements
table_location = path + 'table1'
g = open(table_location, 'r')
elements = g.readlines()
g.close()
# text describing the beam
ap = io.extract_atomic_properties(params.beam, elements)
if (params.ethresh != None):
ap.displ_energy = params.ethresh[0]
f.write("%s %s" % (ap.atomic_number, ap.atomic_mass))
f.write(" %s %s %s" % (ap.bulk_bind_energy, ap.displ_energy, ap.cutoff_energy))
f.write(" 0. 0. %s" % (ap.density_aa)) #fractional composition of bulk material and thin film, respectively (0 for beam) and atomic density.
f.write(" 1.0\n") #electronic stopping correction factor
f.write("%d. %d. %d." % (params.energy, params.angle, extras["azimuthal_angle"]) )
f.write(" 1.00") # beam fraction
# specify the surface binding energies; default case or with SBV provided
sbe_row = ""
if (extras["SBV_matrix"] == None):
sbe_row = " %s" % (ap.surf_bind_energy) # rows in surface binding energy matrix
for kk in range(len(params.target)):
sbe_row += " 0.00"
else:
my_row = extras["SBV_matrix"][0]
for entry in my_row:
sbe_row += " %8f" % (entry)
f.write(sbe_row + "\n")
f.write("-5 0 %d %d 25 0. 0. 0.\n" % (geom.y, geom.z) )
for kk,element in enumerate(params.target):
ap = io.extract_atomic_properties(element[0], elements)
if (params.ethresh != None):
ap.displ_energy = params.ethresh[kk+1]
f.write("%s %s" % (ap.atomic_number, ap.atomic_mass))
#f.write(" %s %s %s" % (ap.bulk_bind_energy, ap.displ_energy, ap.cutoff_energy))
f.write(" %s %s %s" % (0.0, 2.0, 1.0))
bulk_concentration = element[1]
film_concentration = element[1] if extras["film_composition_vector"] == None else extras["film_composition_vector"][kk+1]
f.write(" %s %s %s" % (bulk_concentration, film_concentration, ap.density_aa)) #fractional composition of bulk material and thin film, respectively (0 for beam) and atomic density.
f.write(" 1.0\n") #electronic stopping correction factor
f.write("%d. %d. %d." % (params.energy, params.angle, extras["azimuthal_angle"]) )
f.write(" 0.00") # beam fraction
# rows in surface binding energy matrix
sbe_row = ""
if (extras["SBV_matrix"] == None):
sbe_row = " 0.0"
for ii in range(len(params.target)):
sbe_row += " %s" % (ap.surf_bind_energy)
else:
my_row = extras["SBV_matrix"][kk+1]
for entry in my_row:
sbe_row += " %8f" % (entry)
f.write(sbe_row + "\n")
f.write("-5 0 %d %d 25 0. 0. 0.\n" % (geom.y, geom.z) )
f.close()