def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run surface_energy results_dict = surface_energy(input_dict['lammps_command'], input_dict['ucell'], input_dict['potential'], input_dict['surface_hkl'], mpi_command = input_dict['mpi_command'], sizemults = input_dict['sizemults'], minwidth = input_dict['surface_minwidth'], even = input_dict['surface_even'], conventional_setting = input_dict['surface_cellsetting'], cutboxvector = input_dict['surface_cutboxvector'], shiftindex = input_dict['surface_shiftindex'], etol = input_dict['energytolerance'], ftol = input_dict['forcetolerance'], maxiter = input_dict['maxiterations'], maxeval = input_dict['maxevaluations'], dmax = input_dict['maxatommotion']) # Build and save data model of results record = iprPy.load_record(record_style) record.buildcontent(input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read in parameters from input file with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) #Run pointdiffusion results_dict = pointdiffusion(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], input_dict['point_kwargs'], mpi_command = input_dict['mpi_command'], temperature = input_dict['temperature'], runsteps = input_dict['runsteps'], thermosteps = input_dict['thermosteps'], dumpsteps = input_dict['dumpsteps'], equilsteps = input_dict['equilsteps'], randomseed = input_dict['randomseed']) # Save data model of results script = os.path.splitext(os.path.basename(__file__))[0] record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run ptd_energy to refine values results_dict = calc(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], input_dict['point_kwargs'], 1.05 * input_dict['ucell'].box.a, mpi_command = input_dict['mpi_command'], etol = input_dict['energytolerance'], ftol = input_dict['forcetolerance'], maxiter = input_dict['maxiterations'], maxeval = input_dict['maxevaluations'], dmax = input_dict['maxatommotion']) # Save data model of results script = Path(__file__).stem record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run crystal_compare to compare two systems based on spacegroup info results_dict = crystal_space_group( input_dict['ucell'], symprec=input_dict['symmetryprecision'], to_primitive=input_dict['primitivecell'], no_idealize=not input_dict['idealcell']) # Save data model of results script = Path(__file__).stem record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run relax_static to relax system results_dict = relax_static(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], mpi_command=input_dict['mpi_command'], p_xx=input_dict['pressure_xx'], p_yy=input_dict['pressure_yy'], p_zz=input_dict['pressure_zz'], p_xy=input_dict['pressure_xy'], p_xz=input_dict['pressure_xz'], p_yz=input_dict['pressure_yz'], dispmult=input_dict['displacementkick'], etol=input_dict['energytolerance'], ftol=input_dict['forcetolerance'], maxiter=input_dict['maxiterations'], maxeval=input_dict['maxevaluations'], dmax=input_dict['maxatommotion'], maxcycles=input_dict['maxcycles'], ctol=input_dict['cycletolerance']) # Build and save data model of results record = iprPy.load_record(record_style) record.buildcontent(input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run e_vs_r results_dict = e_vs_r(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], mpi_command = input_dict['mpi_command'], ucell = input_dict['ucell'], rmin = input_dict['minimum_r'], rmax = input_dict['maximum_r'], rsteps = input_dict['number_of_steps_r']) # Save data model of results script = os.path.splitext(os.path.basename(__file__))[0] record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run relax_static to relax system results_dict = baintransformation(input_dict['lammps_command'], input_dict['a_bcc'], input_dict['a_fcc'], input_dict['symbol'], input_dict['sizemults'], input_dict['potential'], mpi_command=input_dict['mpi_command'], num_a=input_dict['number_a_scale'], num_c=input_dict['number_c_scale'], min_a=input_dict['minimum_a_scale'], max_a=input_dict['maximum_a_scale'], min_c=input_dict['minimum_c_scale'], max_c=input_dict['maximum_c_scale'], etol=input_dict['energytolerance'], ftol=input_dict['forcetolerance'], maxiter=input_dict['maxiterations'], maxeval=input_dict['maxevaluations'], dmax=input_dict['maxatommotion']) # Build and save data model of results record = iprPy.load_record(record_style) record.buildcontent(input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read in parameters from input file with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) #Run pointdiffusion results_dict = pointdiffusion(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], input_dict['point_kwargs'], mpi_command=input_dict['mpi_command'], temperature=input_dict['temperature'], runsteps=input_dict['runsteps'], thermosteps=input_dict['thermosteps'], dumpsteps=input_dict['dumpsteps'], equilsteps=input_dict['equilsteps'], randomseed=input_dict['randomseed']) # Save data model of results script = Path(__file__).stem record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run lammps_ELASTIC_refine to refine values results_dict = elastic_constants_static( input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], mpi_command=input_dict['mpi_command'], strainrange=input_dict['strainrange'], etol=input_dict['energytolerance'], ftol=input_dict['forcetolerance'], maxiter=input_dict['maxiterations'], maxeval=input_dict['maxevaluations'], dmax=input_dict['maxatommotion']) # Save data model of results script = os.path.splitext(os.path.basename(__file__))[0] record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run relax_box to refine values results_dict = relax_box(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], mpi_command=input_dict['mpi_command'], p_xx=input_dict['pressure_xx'], p_yy=input_dict['pressure_yy'], p_zz=input_dict['pressure_zz'], p_xy=input_dict['pressure_xy'], p_xz=input_dict['pressure_xz'], p_yz=input_dict['pressure_yz'], strainrange=input_dict['strainrange']) # Save data model of results script = Path(__file__).stem record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run phonon results_dict = phonon( input_dict['lammps_command'], input_dict['ucell'], input_dict['potential'], mpi_command=input_dict['mpi_command'], a_mult=input_dict['sizemults'][0][1] - input_dict['sizemults'][0][0], b_mult=input_dict['sizemults'][1][1] - input_dict['sizemults'][1][0], c_mult=input_dict['sizemults'][2][1] - input_dict['sizemults'][2][0], distance=input_dict['displacementdistance'], symprec=input_dict['symmetryprecision']) # Save data model of results script = Path(__file__).stem record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run surface_energy results_dict = surface_energy(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], mpi_command = input_dict['mpi_command'], etol = input_dict['energytolerance'], ftol = input_dict['forcetolerance'], maxiter = input_dict['maxiterations'], maxeval = input_dict['maxevaluations'], dmax = input_dict['maxatommotion'], cutboxvector = input_dict['surface_cutboxvector']) # Save data model of results script = os.path.splitext(os.path.basename(__file__))[0] record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run full_Relax to refine values results_dict = relax_dynamic(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], mpi_command = input_dict['mpi_command'], p_xx = input_dict['pressure_xx'], p_yy = input_dict['pressure_yy'], p_zz = input_dict['pressure_zz'], p_xy = input_dict['pressure_xy'], p_xz = input_dict['pressure_xz'], p_yz = input_dict['pressure_yz'], temperature = input_dict['temperature'], runsteps = input_dict['runsteps'], integrator = input_dict['integrator'], thermosteps = input_dict['thermosteps'], dumpsteps = input_dict['dumpsteps'], equilsteps = input_dict['equilsteps'], randomseed = input_dict['randomseed']) # Build and save data model of results record = iprPy.load_record(record_style) record.buildcontent(input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) results_dict = dislocationarraystress( input_dict['lammps_command'], input_dict['ucell'], input_dict['potential'], input_dict['temperature'], mpi_command=input_dict['mpi_command'], sigma_xz=input_dict['sigma_xz'], sigma_yz=input_dict['sigma_yz'], runsteps=input_dict['runsteps'], thermosteps=input_dict['thermosteps'], dumpsteps=input_dict['dumpsteps'], randomseed=input_dict['randomseed'], bwidth=input_dict['boundarywidth'], rigidbounds=input_dict['rigidboundaries']) # Save data model of results script = os.path.splitext(os.path.basename(__file__))[0] record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run diatom results_dict = diatom(input_dict['lammps_command'], input_dict['potential'], input_dict['symbols'], mpi_command=input_dict['mpi_command'], rmin=input_dict['minimum_r'], rmax=input_dict['maximum_r'], rsteps=input_dict['number_of_steps_r']) # Save data model of results script = Path(__file__).stem record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) results_dict = dislocationarray( input_dict['lammps_command'], input_dict['ucell'], input_dict['potential'], input_dict['C'], input_dict['dislocation_burgers'], input_dict['dislocation_ξ_uvw'], input_dict['dislocation_slip_hkl'], mpi_command=input_dict['mpi_command'], m=input_dict['dislocation_m'], n=input_dict['dislocation_n'], sizemults=input_dict['sizemults'], amin=input_dict['amin'], bmin=input_dict['bmin'], cmin=input_dict['cmin'], shift=input_dict['dislocation_shift'], shiftscale=input_dict['dislocation_shiftscale'], shiftindex=input_dict['dislocation_shiftindex'], etol=input_dict['energytolerance'], ftol=input_dict['forcetolerance'], maxiter=input_dict['maxiterations'], maxeval=input_dict['maxevaluations'], dmax=input_dict['maxatommotion'], annealtemp=input_dict['annealtemperature'], annealsteps=input_dict['annealsteps'], randomseed=input_dict['randomseed'], boundarywidth=input_dict['dislocation_boundarywidth'], boundaryscale=input_dict['dislocation_boundaryscale'], linear=input_dict['dislocation_onlylinear'], cutoff=input_dict['dislocation_duplicatecutoff']) # Build and save data model of results record = iprPy.load_record(record_style) record.buildcontent(input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) results_dict = peierlsnabarro( input_dict['ucell'], input_dict['C'], input_dict['dislocation_burgers'], input_dict['dislocation_ξ_uvw'], input_dict['dislocation_slip_hkl'], input_dict['gamma'], m=input_dict['dislocation_m'], n=input_dict['dislocation_n'], cutofflongrange=input_dict['cutofflongrange'], tau=input_dict['tau'], alpha=input_dict['alpha'], beta=input_dict['beta'], cdiffelastic=input_dict['cdiffelastic'], cdiffsurface=input_dict['cdiffsurface'], cdiffstress=input_dict['cdiffstress'], fullstress=input_dict['fullstress'], halfwidth=input_dict['halfwidth'], normalizedisreg=input_dict['normalizedisreg'], xnum=input_dict['xnum'], xstep=input_dict['xstep'], xmax=input_dict['xmax'], min_method=input_dict['minimize_style'], min_options=input_dict['minimize_options'], min_cycles=input_dict['minimize_cycles']) # Save data model of results script = Path(__file__).stem record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run diatom results_dict = isolated_atom(input_dict['lammps_command'], input_dict['potential']) # Build and save data model of results record = iprPy.load_record(record_style) record.buildcontent(input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) results_dict = stackingfaultmap( input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], input_dict['shiftvector1'], input_dict['shiftvector2'], mpi_command=input_dict['mpi_command'], numshifts1=input_dict['stackingfault_numshifts1'], numshifts2=input_dict['stackingfault_numshifts2'], cutboxvector=input_dict['stackingfault_cutboxvector'], faultpos=input_dict['faultpos'], etol=input_dict['energytolerance'], ftol=input_dict['forcetolerance'], maxiter=input_dict['maxiterations'], maxeval=input_dict['maxevaluations'], dmax=input_dict['maxatommotion']) results_dict['gamma'] = am.defect.GammaSurface( a1vect=input_dict['stackingfault_shiftvector1'], a2vect=input_dict['stackingfault_shiftvector2'], box=input_dict['ucell'].box, a1=results_dict['shift1'], a2=results_dict['shift2'], E_gsf=results_dict['E_gsf']) # Save data model of results script = os.path.splitext(os.path.basename(__file__))[0] record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) results_dict = stackingfaultmap(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], input_dict['shiftvector1'], input_dict['shiftvector2'], mpi_command = input_dict['mpi_command'], numshifts1 = input_dict['stackingfault_numshifts1'], numshifts2 = input_dict['stackingfault_numshifts2'], cutboxvector = input_dict['stackingfault_cutboxvector'], faultpos = input_dict['faultpos'], etol = input_dict['energytolerance'], ftol = input_dict['forcetolerance'], maxiter = input_dict['maxiterations'], maxeval = input_dict['maxevaluations'], dmax = input_dict['maxatommotion']) results_dict['gamma'] = am.defect.GammaSurface(a1vect = input_dict['stackingfault_shiftvector1'], a2vect = input_dict['stackingfault_shiftvector2'], box = input_dict['ucell'].box, a1 = results_dict['shift1'], a2 = results_dict['shift2'], E_gsf = results_dict['E_gsf']) # Save data model of results script = os.path.splitext(os.path.basename(__file__))[0] record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) results_dict = dislocationmonopole( input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], input_dict['burgersvector'], input_dict['C'], mpi_command=input_dict['mpi_command'], axes=input_dict['transformationmatrix'], m=input_dict['stroh_m'], n=input_dict['stroh_n'], lineboxvector=input_dict['dislocation_lineboxvector'], etol=input_dict['energytolerance'], ftol=input_dict['forcetolerance'], maxiter=input_dict['maxiterations'], maxeval=input_dict['maxevaluations'], dmax=input_dict['maxatommotion'], annealtemp=input_dict['annealtemperature'], annealsteps=input_dict['annealsteps'], randomseed=input_dict['randomseed'], bshape=input_dict['dislocation_boundaryshape'], bwidth=input_dict['boundarywidth']) # Save data model of results script = Path(__file__).stem record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) results_dict = dislocationmonopole(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], input_dict['burgersvector'], input_dict['C'], mpi_command = input_dict['mpi_command'], axes = input_dict['transformationmatrix'], m = input_dict['stroh_m'], n = input_dict['stroh_n'], lineboxvector = input_dict['dislocation_lineboxvector'], etol = input_dict['energytolerance'], ftol = input_dict['forcetolerance'], maxiter = input_dict['maxiterations'], maxeval = input_dict['maxevaluations'], dmax = input_dict['maxatommotion'], annealtemp = input_dict['annealtemperature'], randomseed = input_dict['randomseed'], bshape = input_dict['dislocation_boundaryshape'], bwidth = input_dict['boundarywidth']) # Save data model of results script = os.path.splitext(os.path.basename(__file__))[0] record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run full_Relax to refine values results_dict = relax_dynamic(input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], mpi_command = input_dict['mpi_command'], p_xx = input_dict['pressure_xx'], p_yy = input_dict['pressure_yy'], p_zz = input_dict['pressure_zz'], p_xy = input_dict['pressure_xy'], p_xz = input_dict['pressure_xz'], p_yz = input_dict['pressure_yz'], temperature = input_dict['temperature'], runsteps = input_dict['runsteps'], integrator = input_dict['integrator'], thermosteps = input_dict['thermosteps'], dumpsteps = input_dict['dumpsteps'], equilsteps = input_dict['equilsteps'], randomseed = input_dict['randomseed']) # Save data model of results script = os.path.splitext(os.path.basename(__file__))[0] record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function for running calculation""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) #Read in potential potential = lmp.Potential(input_dict['potential'], input_dict['potential_dir']) #Get axes info axes = np.array( [input_dict['x-axis'], input_dict['y-axis'], input_dict['z-axis']]) # Perform crss calculation results_dict = crss(input_dict['lammps_command'], input_dict['initial_system'], potential, input_dict['C'], mpi_command=input_dict['mpi_command'], chi=input_dict['chi_angle'], sigma=input_dict['sigma'], tau_1=input_dict['tau_1'], tau_2=input_dict['tau_2'], press=input_dict['press'], rss_steps=input_dict['rss_steps'], axes=axes) # Build and save data model of results record = iprPy.load_record(record_style) record.buildcontent(input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) results_dict = stackingfault( input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], mpi_command=input_dict['mpi_command'], a1vect=input_dict['shiftvector1'], a2vect=input_dict['shiftvector2'], ucell=input_dict['ucell'], transform=input_dict['transformationmatrix'], cutboxvector=input_dict['stackingfault_cutboxvector'], faultposrel=input_dict['faultpos'], a1=input_dict['stackingfault_shiftfraction1'], a2=input_dict['stackingfault_shiftfraction2'], etol=input_dict['energytolerance'], ftol=input_dict['forcetolerance'], maxiter=input_dict['maxiterations'], maxeval=input_dict['maxevaluations'], dmax=input_dict['maxatommotion']) # Save data model of results script = Path(__file__).stem record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) # Run crystal_compare to compare two systems based on spacegroup info results_dict = crystal_space_group(input_dict['ucell'], symprec=input_dict['symmetryprecision'], to_primitive=input_dict['primitivecell'], no_idealize=not input_dict['idealcell']) # Save data model of results script = os.path.splitext(os.path.basename(__file__))[0] record = iprPy.load_record(record_style) record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)
def main(*args): """Main function called when script is executed directly.""" # Read input file in as dictionary with open(args[0]) as f: input_dict = iprPy.input.parse(f, allsingular=True) # Interpret and process input parameters process_input(input_dict, *args[1:]) results_dict = DM() results_dict['neb_log'] = calc_neb( input_dict['lammps_command'], input_dict['initialsystem'], input_dict['potential'], input_dict['initialdefect_number'], input_dict['defectpair_number'], input_dict['point_mobility_kwargs'], input_dict['allSymbols'], mpi_command=input_dict['mpi_command'], etol=input_dict['energytolerance'], #From lammps_min ftol=input_dict['forcetolerance'], #From lammps_min dmax=input_dict['maxatommotion'], #From lammps_min nreplicas=input_dict['numberreplicas'], #For NEB springconst=input_dict['springconst'], #For NEB thermosteps=input_dict['thermosteps'], #For NEB dumpsteps=input_dict['dumpsteps'], # For minimization settings timestep=input_dict['timestep'], # For minimization setings minsteps=input_dict['minsteps'], #For NEB climbsteps=input_dict['climbsteps'] #For NEB ) # Load log from completed NEB neb = lmp.NEBLog() #Printing the number of replicas, and the log for the minruns and climbruns print('There were', neb.nreplicas, 'replicas') print(neb.minrun) print(neb.climbrun) #Creating a figure which contains the energy vs movement coordinate information #for the initial system, the final minimized system, and the climbed system fig = plt.figure() rx, e = neb.get_neb_path(0) results_dict['unrelaxed_run'] = DM() results_dict['unrelaxed_run']['coordinates'] = rx.tolist() results_dict['unrelaxed_run']['energy'] = e.tolist() plt.plot(rx, e, 'o:', label='unrelaxed') rx, e = neb.get_neb_path(neb.minrun.Step.values[-1]) results_dict['final_minimized_run'] = DM() results_dict['final_minimized_run']['coordinates'] = rx.tolist() results_dict['final_minimized_run']['energy'] = e.tolist() plt.plot(rx, e, 'o:', label='after min run') rx, e = neb.get_neb_path(neb.climbrun.Step.values[-1]) plt.plot(rx, e, 'o:', label='after climb run') results_dict['final_climb_run'] = DM() results_dict['final_climb_run']['coordinates'] = rx.tolist() results_dict['final_climb_run']['energy'] = e.tolist() plt.legend() plt.title('Defect Formation energy vs Normalized Migration Coordinate') plt.xlabel('Migration Coordinate') plt.ylabel('Change in formation energy (eV)') fig.savefig('EnergyvsCoord.png') #Creating a figure which combines the minimum energy path after the #minimization step and the climb steps, to give the fullest description #of the minimum energy path fig2 = plt.figure() rx1, e1 = neb.get_neb_path(neb.minrun.Step.values[-1]) rx2, e2 = neb.get_neb_path(neb.climbrun.Step.values[-1]) rx = [] e = [] index1 = 0 index2 = 0 while index2 < len(rx2): #Going through the coordinates of the if rx1[index1] < rx2[index2]: #minimum and climb steps so that they rx.append(rx1[index1]) #are properly ordered e.append(e1[index1]) index1 = index1 + 1 elif rx1[index1] > rx2[index2]: rx.append(rx2[index2]) e.append(e2[index2]) index2 = index2 + 1 elif rx1[index1] == rx2[index1]: rx.append(rx1[index1]) e.append(e1[index1]) index1 = index1 + 1 index2 = index2 + 1 #Storing and ploting resulting information results_dict['min_and_climb_run'] = DM() results_dict['min_and_climb_run']['coordinates'] = rx results_dict['min_and_climb_run']['energy'] = e plt.plot(rx, e, 'o:', label='Min and Climb Run Combined') plt.legend() plt.title('Defect Formation energy vs Normalized Migration Coordinate') plt.xlabel('Migration Coordinate') plt.ylabel('Change in formation energy (eV)') #Creating a record using the calc_point_defect_mobility format record = iprPy.load_record(record_style) fig2.savefig('min_climb_combined.png') #Printing the information on the forward and reverse energy barrier, #and storing it in the results dict print('Forward barrier =', uc.get_in_units(neb.get_barrier(), 'eV'), 'eV') print('Reverse barrier =', uc.get_in_units(neb.get_barrier(reverse=True), 'eV'), 'eV') script = os.path.splitext(os.path.basename(__file__))[0] results_dict['barrier'] = DM() results_dict['barrier']['energy_units'] = 'eV' results_dict['barrier']['forward_barrier'] = uc.get_in_units( neb.get_barrier(), 'eV') results_dict['barrier']['reverse_barrier'] = uc.get_in_units( neb.get_barrier(reverse=True), 'eV') #building a record and printing it record.buildcontent(script, input_dict, results_dict) with open('results.json', 'w') as f: record.content.json(fp=f, indent=4)