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()