def main(): atoms = bulk("Al", cubic=True) atoms = atoms * (3, 3, 3) for i in range(int(len(atoms) / 5)): atoms[i].symbol = "Mg" atoms.rattle(stdev=0.005) calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=(4, 4, 4), nbands="120%") atoms.set_calculator(calc) logfile = "relax250.log" traj = "relax250.traj" trajObj = Trajectory(traj, 'w', atoms) precon = Exp(mu=1) relaxer = PreconLBFGS(atoms, logfile=logfile, use_armijo=True, precon=precon, memory=50) #relaxer = PreconFIRE( atoms, logfile=logfile, use_armijo=True, precon=precon ) relaxer.attach(trajObj) try: relaxer.run(fmax=0.05) except Exception as exc: print(exc)
def main(argv): n_mg = int(argv[0]) atoms = bulk("Al") atoms = atoms * (4, 4, 4) for i in range(n_mg): atoms[i].symbol = "Mg" atoms.rattle(stdev=0.005) calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=(4, 4, 4), nbands="120%") atoms.set_calculator(calc) logfile = "preconTest%d.log" % (n_mg) traj = "preconTest%d.traj" % (n_mg) trajObj = Trajectory(traj, 'w', atoms) precon = Exp(mu=1) relaxer = PreconLBFGS(atoms, logfile=logfile, use_armijo=True, precon=precon) relaxer.attach(trajObj) try: relaxer.run(fmax=0.05) except: pass print("Mu: %.2E" % (relaxer.precon.mu))
def main(argv): fname = argv[0] if (int(argv[1]) == 1): variable_cell = True else: variable_cell = False atoms = read(fname) #atoms = bulk("Al") calc = gp.GPAW(mode=gp.PW(500), kpts=(12, 12, 12), xc="PBE", nbands=-20) atoms.set_calculator(calc) prc = Exp(mu=1.0, mu_c=1.0) outfname = fname.split("/")[-1] outfname = outfname.split(".")[0] logfile = outfname + ".log" traj_file = outfname + ".traj" relaxer = PreconLBFGS(atoms, logfile=logfile, precon=prc, use_armijo=True, variable_cell=variable_cell) trajObj = Trajectory(traj_file, 'w', atoms) relaxer.attach(trajObj) if (variable_cell): relaxer.run(fmax=0.025, smax=0.003) else: relaxer.run(fmax=0.025) outfname = fname.split("/")[-1] outfname = outfname.split(".")[0] outfname += "_relaxed.xyz" print("Energy: {}".format(atoms.get_potential_energy())) write(outfname, atoms)
def relax(runID): db = connect(db_name) atoms = db.get_atoms(id=runID) con = sq.connect(db_name) cur = con.cursor() cur.execute("SELECT value FROM text_key_values WHERE id=? AND key='name'", (runID, )) name = cur.fetchone()[0] con.close() calc = gp.GPAW(mode=gp.PW(600), xc="PBE", kpts=(4, 4, 4), nbands="120%", symmetry="off") atoms.set_calculator(calc) precon = Exp(mu=1.0, mu_c=1.0) save_to_db = SaveToDB(db_name, runID, name) logfile = "logfile%d.log" % (runID) traj = "trajectory%d.traj" % (runID) uf = UnitCellFilter(atoms, hydrostatic_strain=True) relaxer = PreconLBFGS(uf, logfile=logfile, use_armijo=True, precon=precon) relaxer.attach(save_to_db, interval=1, atoms=atoms) trajObj = Trajectory(traj, "w", atoms) relaxer.attach(trajObj) relaxer.run(fmax=0.05, smax=0.003)
def main(): database = "aluminum.db" # Parse parameters from the database con = sqdb.connect(database) cur = con.cursor() cur.execute( "SELECT VIEW,CUTOFF,KPTS,LATTICEPARAM,_rowid_,STRUCTURE FROM PARAMS WHERE STATUS=?", ("RUN", )) jobs = cur.fetchall() con.close() print(jobs) for job in jobs: stamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S") structure = job[5] a = job[3] show = job[0] b = a / 2.0 if (structure == "FCC"): bulk = Atoms("Al", cell=[[0, b, b], [b, 0, b], [b, b, 0]], pbc=True) elif (structure == "BCC"): bulk = Atoms("Al", cell=[[b, b, b], [b, b, -b], [b, -b, b]], pbc=True) else: print("Unknown lattice type") continue if (show == 1): view(bulk) calcfile = "data/alum" + structure + stamp + ".txt" cutoff = job[1] k = job[2] calc = gp.GPAW(mode=gp.PW(cutoff), kpts=(k, k, k), txt=calcfile, xc="LDA") bulk.set_calculator(calc) energy = bulk.get_potential_energy() gpwfile = "data/alum" + structure + stamp + ".gpw" calc.write(gpwfile) # Update the database aseDB = db.connect(database) lastID = aseDB.write(bulk) con = sqdb.connect(database) cur = con.cursor() row = int(job[4]) cur.execute( "UPDATE PARAMS SET GPWFILE=?,TXTFILE=?,STATUS=?,ID=? WHERE _rowid_=?", (gpwfile, calcfile, "FINISHED", lastID, row)) con.commit() con.close()
def relax(fname): atoms = read(fname) calc = gp.GPAW(mode=gp.PW(600),kpts=(4,4,4),xc="PBE") atoms.set_calculator(calc) uf = UnitCellFilter(atoms,hydrostatic_strain=True) relaxer = PreconLBFGS( uf, logfile="logfile.log" ) relaxer.run( fmax=0.025,smax=0.003 ) write( fname, atoms )
def main(runID): db = connect(db_name) calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=(8, 8, 8), nbands=-50) atoms = db.get_atoms(id=runID) atoms.set_calculator(calc) energy = atoms.get_potential_energy() del db[runID] db.write(atoms)
def run_dft(): kpt = 16 atoms = bulk("Al",crystalstructure="fcc",a=4.05) calc = gp.GPAW( mode=gp.PW(600), xc="PBE", kpts=(kpt,kpt,kpt), nbands=-50 ) atoms.set_calculator( calc ) relaxer = BFGS( UnitCellFilter(atoms) ) relaxer.run( fmax=0.025 ) energy = atoms.get_potential_energy() print (energy)
def main(): atoms = build.bulk("Al") atoms = atoms * (8, 4, 4) nMg = int(0.2 * len(atoms)) for i in range(nMg): atoms[i].symbol = "Mg" calc = gp.GPAW(mode=gp.PW(400), xc="PBE", nbands=-10, kpts=(4, 4, 4)) atoms.set_calculator(calc) energy = atoms.get_potential_energy() / len(atoms)
def originalCalculation(): atoms = bulk("Al", cubic=True) calc = gp.GPAW(mode=gp.PW(350), nbands=-50, xc="PBE", kpts={"density": 1.37, "even": True}) atoms.set_calculator(calc) energy = atoms.get_potential_energy() calc.write( "al.gpw", mode="all" ) n = calc.get_all_electron_density(gridrefinement=4) np.save("density_al.npy", n) view(atoms, viewer="avogadro", data=n) ase.io.write("al_density.cube", atoms, data=n)
def main(runID): db = ase.db.connect(db_name()) atoms = db.get_atoms(id=runID) row = db.get(id=runID) n_kpt = row.n_kpt cutoff = row.cutoff calc = gp.GPAW(mode=gp.PW(cutoff), xc="PBE", kpts=(n_kpt, n_kpt, n_kpt), nbands="120%") atoms.set_calculator(calc) energy = atoms.get_potential_energy() db.update(runID, trial_energy=energy)
def main(argv): atoms = bulk("Al") atoms = atoms * (4, 4, 4) mode = "fd" e_cut = 500 if (mode == "fd"): h = 0.2 calc = gp.GPAW(mode="fd", h=h, xc="PBE", kpts=(6, 6, 6), nbands=-10) else: calc = gp.GPAW(mode=gp.PW(e_cut), xc="PBE", kpts=(6, 6, 6), nbands=-10) atoms.set_calculator(calc) energy = atoms.get_potential_energy() print("Energy: %.2E" % (energy))
def main(runID): db = connect(db_name) atoms = db.get_atoms(id=runID) N = 14 calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=(N, N, N), nbands=-50, symmetry={'do_not_symmetrize_the_density': True}) atoms.set_calculator(calc) precon = Exp(mu=1.0, mu_c=1.0) uf = UnitCellFilter(atoms, hydrostatic_strain=True) logfile = "al3mg2{}.log".format(runID) relaxer = PreconLBFGS(uf, logfile=logfile, use_armijo=True, precon=precon) relaxer.run(fmax=0.025, smax=0.003) energy = atoms.get_potential_energy() del db[db.get(id=runID)] db.write(atoms)
def compute_bulk(fname): atoms = read(fname) calc = gp.GPAW(mode=gp.PW(600),kpts=(4,4,4),xc="PBE") energies = [] base_fname = fname.split(".")[0] lat_params = np.loadtxt( base_fname+"_latparam.csv", delimiter="," ) V0 = atoms.get_volume() a0 = (V0)**(1.0/3.0) for a in lat_params: sim_atoms = atoms.copy() cell = sim_atoms.get_cell() cell *= (a/a0) sim_atoms.set_cell(cell,scale_atoms=True) sim_atoms.set_calculator(calc) energy = sim_atoms.get_potential_energy() energies.append(energy/len(sim_atoms)) out = np.vstack((lat_params,energies)).T np.savetxt( base_fname+"_bulk.csv",out,delimiter=",",header="Lattice parameter,energy per atom")
def main(argv): n_mg = int(argv[0]) atoms = bulk("Al") atoms = atoms * (4, 4, 4) for i in range(n_mg): atoms[i].symbol = "Mg" atoms.rattle(stdev=0.005) calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=(4, 4, 4), nbands="120%") atoms.set_calculator(calc) logfile = "bfgsTest%d.log" % (n_mg) traj = "bfgsTest%d.traj" % (n_mg) trajObj = Trajectory(traj, 'w', atoms) relaxer = BFGS(atoms, logfile=logfile) relaxer.attach(trajObj) try: relaxer.run(fmax=0.05) except: pass
def main(): unitcellSize = 10.0 # Size of unit cell in Angstrohm center = unitcellSize/2.0 # Create Hydrogen atom located at the center of the unitcell atom = ase.Atoms( "H", positions=[(center,center,center)], magmoms=[0], cell=(center,center+0.001, center+0.002)) # Initialize the GPAW calculator calc = gp.GPAW( mode=gp.PW(), xc="PBE", hund=True, eigensolver="rmm-diis", occupations=gp.FermiDirac(0.0, fixmagmom=True), txt="hydrogen.out") atom.set_calculator( calc ) print ("Solving single atom...") e1 = atom.get_potential_energy() calc.write("H.gpw") # Simulate hydrogen molecule d = 0.74 # Bond length molecule = ase.Atoms( "H2", positions=([center-d/2.0,center,center],[center+d/2.0,center,center]), cell=(center,center,center)) calc.set(txt="H.out") calc.set(hund=False) molecule.set_calculator( calc ) print ("Solving hydrogen molecule...") e2 = molecule.get_potential_energy() # Test if it recalculates everytime for i in range(10): e2 = molecule.get_potential_energy() print (e2) calc.write("H2.gpw") print ( "Hydrogen atom energy: %.2f eV"%(e1) ) print ( "Hydrogen molecule energy: %.2f eV"%(e2) ) print ( "Atomization energy: %.2f eV"%(2*e1-e2) )
def main(argv): relaxCell = True system = "AlMg" runID = int(argv[0]) print("Running job: %d" % (runID)) db_paths = [ "/home/ntnu/davidkl/GPAWTutorial/CE/ce_hydrostatic.db", "ce_hydrostatic.db", "/home/davidkl/GPAWTutorial/CE/ce_hydrostatic.db" ] for path in db_paths: if (os.path.isfile(path)): db_name = path break #db_name = "/home/ntnu/davidkl/Documents/GPAWTutorials/ceTest.db" db = ase.db.connect(db_name) con = sq.connect(db_name) cur = con.cursor() cur.execute("SELECT value FROM text_key_values WHERE id=? AND key='name'", (runID, )) name = cur.fetchone()[0] con.close() new_run = not db.get(id=runID).key_value_pairs["started"] # Update the databse db.update(runID, started=True, converged=False) atoms = db.get_atoms(id=runID) if (system == "AlMg" and new_run == False): atoms = change_cell_composition_AlMg(atoms) convergence = {"density": 1E-4, "eigenstates": 4E-8} calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=(4, 4, 4), nbands="120%", convergence=convergence) atoms.set_calculator(calc) logfile = "ceTest%d.log" % (runID) traj = "ceTest%d.traj" % (runID) trajObj = Trajectory(traj, 'w', atoms) storeBest = SaveToDB(db_name, runID, name) try: precon = Exp(mu=1.0, mu_c=1.0) if (relaxCell): uf = UnitCellFilter(atoms, hydrostatic_strain=True) relaxer = PreconLBFGS(uf, logfile=logfile, use_armijo=True, precon=precon) else: relaxer = PreconFIRE(atoms, logfile=logfile, precon=precon) relaxer = SciPyFminCG(atoms, logfile=logfile) relaxer.attach(trajObj) relaxer.attach(storeBest, interval=1, atoms=atoms) if (relaxCell): relaxer.run(fmax=0.025, smax=0.003) else: relaxer.run(fmax=0.025) energy = atoms.get_potential_energy() db.update(storeBest.runID, converged=True) print("Energy: %.2E eV/atom" % (energy / len(atoms))) print("Preconditioner parameters") print("Mu:", precon.mu) print("Mu_c:", precon.mu_c) except Exception as exc: print(exc)
import gpaw as gp from ase.build import bulk from ase.visualize import view from ase.optimize.precon import PreconLBFGS from ase.io import write from ase.calculators.emt import EMT atoms = bulk("Mg", crystalstructure="fcc", a=4.1) atoms = atoms * (2, 2, 2) si_indx = [1, 2, 4, 7] for indx in si_indx: atoms[indx].symbol = "Si" calc = gp.GPAW(mode=gp.PW(600), xc="PBE", kpts=(2, 2, 2), nbands=-100) atoms.set_calculator(calc) opt = PreconLBFGS(atoms, variable_cell=True) opt.run(fmax=0.025, smax=0.003) write("data/relaxed_mgsi.xyz", atoms)
def main(): runID = 20 # ID in the SQL database kpt_density = 5.4 print("Running job: {}".format(runID)) db_name = "database_with_structures.db" # Create a database connection db = connect(db_name) # Retrieve the unique name of this particular entry name = db.get(id=runID).key_value_pairs["name"] # Update the databse db.update(runID, started=True, converged=False) db.update(runID, kpt_density=kpt_density) # Get the atoms object from the database atoms = db.get_atoms(id=runID) nbands = "120%" # Number of electronic bands kpts = {"density": kpt_density, "even": True} calc = gp.GPAW(mode=gp.PW(600), xc="PBE", kpts=kpts, nbands=nbands) atoms.set_calculator(calc) logfile = "prebeta{}.log".format(runID) traj = "prebeta{}.traj".format(runID) # Initialize a trajactory file trajObj = Trajectory(traj, 'w', atoms) # Initialize the relaxer relaxer = PreconLBFGS(atoms, logfile=logfile, use_armijo=True, variable_cell=True) # Attach the trajectory file to the relaxer relaxer.attach(trajObj) # Run until force and stress criteria have been met fmax = 0.025 # Maximum force in eV/Å smax = 0.003 # Maximum stress in eV/Å^3 relaxer.run(fmax=fmax, smax=smax) # Get and print the total energy energy = atoms.get_potential_energy() print("Energy: {}".format(energy)) # What follows is very crucial that it is done exactly like this # Retrieve the original (unrelaxed object) from the database orig_atoms = db.get_atoms(id=runID) # Attacha singlet point calculator with the energy of the relaxed structure scalc = SinglePointCalculator(orig_atoms, energy=energy) orig_atoms.set_calculator(scalc) # Get a all the key_value_pairs kvp = db.get(id=runID).key_value_pairs # Delete the original entry del db[runID] # Write the new objet to the database # Unrelaxed system, with the energy of the relaxed one newID = db.write(orig_atoms, key_value_pairs=kvp) # Update the converged flag db.update(newID, converged=True) # Store also the relaxed object (NOTE: they are linked via their name) db.write(atoms, name=name, state="relaxed")
def main(): atoms = build.bulk("Al") atoms = atoms * (2, 2, 2) print(len(atoms)) nRuns = 10 optimizerFname = "optimizer.pck" for i in range(nRuns): nMgAtoms = np.random.randint(0, len(atoms) / 2) # Insert Mg atoms system = cp.copy(atoms) if (parallel.rank == 0): for j in range(nMgAtoms): system[i].symbol = "Mg" # Shuffle the list for j in range(10 * len(system)): first = np.random.randint(0, len(system)) second = np.random.randint(0, len(system)) symb1 = system[first].symbol system[first].symbol = system[second].symbol system[second].symbol = symb1 system = parallel.broadcast(system) # Initialize the calculator calc = gp.GPAW(mode=gp.PW(400), xc="PBE", kpts=(4, 4, 4), nbands=-10) system.set_calculator(calc) traj = Trajectory("trajectoryResuse.traj", 'w', atoms) if (i == 0): relaxer = PreconLBFGS(UnitCellFilter(system), logfile="resuse.log") else: relaxer = None relaxParams = None if (parallel.rank == 0): with open(optimizerFname, 'rb') as infile: relaxParams = pck.load(infile) relaxParams = parallel.broadcast(relaxParams) precon = Exp(r_cut=relaxParams["r_cut"], r_NN=relaxParams["r_NN"], mu=relaxParams["mu"], mu_c=relaxParams["mu_c"]) relaxer = PreconLBFGS(UnitCellFilter(system), logfile="resuse.log", precon=precon) relaxer.attach(traj) relaxer.run(fmax=0.05) print(relaxer.iteration) if (parallel.rank == 0): with open(optimizerFname, 'wb') as outfile: relaxParams = { "r_cut": relaxer.precon.r_cut, "r_NN": relaxer.precon.r_NN, "mu": relaxer.precon.mu, "mu_c": relaxer.precon.mu_c } pck.dump(relaxParams, outfile, pck.HIGHEST_PROTOCOL) parallel.barrier()
def get_calc(): calc = gp.GPAW( mode=gp.PW(500), xc="PBE", kpts=(8,8,8), nbands=-20, symmetry={'do_not_symmetrize_the_density': True} ) return calc
def main(argv): relax_mode = "both" # both, cell, positions system = "AlMg" runID = int(argv[0]) nkpt = int(argv[1]) single_point = False if (len(argv) >= 3): single_point = (int(argv[2]) == 1) print("Running job: %d" % (runID)) db_paths = [ "/home/ntnu/davidkl/GPAWTutorial/CE/almg_fcc_vac.db", "almg_fcc_vac.db", "/home/davidkl/GPAWTutorial/CE/almg_fcc_vac.db" ] for path in db_paths: if (os.path.isfile(path)): db_name = path break #db_name = "almgsi_test_db.db" db = ase.db.connect(db_name) name = db.get(id=runID).key_value_pairs["name"] new_run = not db.get(id=runID).key_value_pairs["started"] # Update the databse db.update(runID, started=True, converged=False) db.update(runID, nkpt=nkpt) atoms = db.get_atoms(id=runID) atoms = delete_vacancies(atoms) if (len(atoms) == 1): nbands = -10 else: nbands = "120%" kpts = (nkpt, nkpt, nkpt) try: restart_name = SaveRestartFiles.restart_name(name) atoms, calc = gp.restart(restart_name) except: calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=kpts, nbands=nbands) atoms.set_calculator(calc) if (single_point): calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=kpts, nbands=nbands) atoms.set_calculator(calc) logfile = "almg_fcc_vac{}.log".format(name) traj = "almg_bcc{}.traj".format(name) db.update(runID, trajfile=traj) trajObj = Trajectory(traj, 'w', atoms) #storeBest = SaveToDB(db_name,runID,name,mode=relax_mode) save_calc = SaveRestartFiles(calc, name) update_db_info = UpdateDBInfo(db_name, runID, atoms) volume = atoms.get_volume() try: precon = Exp(mu=1.0, mu_c=1.0) fmax = 0.025 smax = 0.003 if (relax_mode == "both"): relaxer = PreconLBFGS(atoms, logfile=logfile, use_armijo=True, variable_cell=True) elif (relax_mode == "positions"): #relaxer = SciPyFminCG( atoms, logfile=logfile ) relaxer = BFGS(atoms, logfile=logfile) elif (relax_mode == "cell"): str_f = StrainFilter(atoms, mask=[1, 1, 1, 0, 0, 0]) relaxer = BFGS(str_f, logfile=logfile) fmax = smax * volume relaxer.attach(trajObj) #relaxer.attach( storeBest, interval=1, atoms=atoms ) relaxer.attach(save_calc, interval=1) relaxer.attach(update_db_info, interval=1) if (not single_point): if (relax_mode == "both"): relaxer.run(fmax=fmax, smax=smax) else: relaxer.run(fmax=fmax) energy = atoms.get_potential_energy() orig_atoms = db.get_atoms(runID) single_p_calc = SinglePointCalculator(orig_atoms, energy=energy) orig_atoms.set_calculator(single_p_calc) kvp = db.get(name=name).key_value_pairs del db[runID] newID = db.write(orig_atoms, key_value_pairs=kvp) if (relax_mode == "positions"): db.update(newID, converged_force=True) elif (relax_mode == "cell"): db.update(newID, converged_stress=True) else: db.update(newID, converged_stress=True, converged_force=True) db.update(newID, single_point=single_point) db.update(newID, restart_file=SaveRestartFiles.restart_name(name)) row = db.get(id=newID) conv_force = row.get("converged_force", default=0) conv_stress = row.get("converged_stress", default=0) if ((conv_force == 1) and (conv_stress == 1) and (nkpt == 4)): db.update(newID, converged=True) except Exception as exc: print(exc)
def main(argv): uid = int(argv[0]) attempt_restart = 1 kpts_density = 1.37 lattice_param = 4.05 relax_atoms = 0 final_structure = 0 optimizer = "lbfgs" init_from_traj = 0 for arg in argv: if arg.find("--restart=") != -1: attempt_restart = int(arg.split("--restart")[1]) elif "--kpt=" in arg: kpts_density = float(arg.split("--kpt=")[1]) elif "--a=" in arg: lattice_param = float(arg.split("--a=")[1]) elif "--relax=" in arg: relax_atoms = int(arg.split("--relax=")[1]) elif "--final=" in arg: final_structure = int(arg.split("--final=")[1]) elif "--opt=" in arg: optimizer = arg.split("--opt=")[1] elif "--traj=" in arg: init_from_traj = int(arg.split("--traj=")[1]) db = connect(db_name) atoms = db.get(id=uid).toatoms() atoms = delete_vacancies(atoms) name = db.get(id=uid).name kpt = {"density": kpts_density, "even": True} # calc = gp.GPAW(h=0.32, kpts=kpt, xc="PBE", nbands="120%") calc = gp.GPAW(mode=gp.PW(600), kpts=kpt, xc="PBE", nbands="120%") atoms.set_calculator(calc) restart_file = db.get(id=uid).get("restart_file", "") if relax_atoms == 0 and final_structure == 0: atoms.get_potential_energy() # Store the energy of the atoms object with the correct name # and lattice parameter db.write(atoms, name=name, lattice_param=lattice_param, run_type="lattice_param_estimation") elif relax_atoms == 1: if os.path.exists(restart_file) and attempt_restart == 1: atoms, calc = gp.restart(restart_file) elif init_from_traj: trajfile = "trajectory{}.traj".format(name) traj = Trajectory(trajfile, 'r') atoms = traj[-1] atoms.set_calculator(calc) else: db.update(uid, restart_file=SaveRestartFiles.restart_name(name)) restart_saver = SaveRestartFiles(calc, name) trajObj = Trajectory("trajectory{}.traj".format(name), 'a', atoms) ucf = UnitCellFilter(atoms, hydrostatic_strain=True) logfile = "log_{}.txt".format(name) if optimizer == "cg": relaxer = SciPyFminCG(ucf, logfile=logfile) elif optimizer == "fire": relaxer = PreconFIRE(ucf, logfile=logfile) else: relaxer = PreconLBFGS(ucf, logfile=logfile) relaxer.attach(trajObj) relaxer.attach(restart_saver, interval=1) relaxer.run(fmax=0.025) db.write(atoms, name=name, lattice_param=lattice_param, run_type="geometry_opt", restart_file=SaveRestartFiles.restart_name(name)) elif final_structure: atoms.get_potential_energy() uid = db.write(atoms, name=name, struct_type="final", kpts_density=kpts_density) init_id = db.get(name=name, struct_type='initial').id db.update(init_id, final_struct_id=uid, converged=1)
def main( argv ): runID = int( argv[0] ) params = { "cutoff":200, "kpts":1, "n_atoms_to_shift":0, "nbands":-1, "relax":False, "gamma":False } db_name = "none" dbPaths = [ "/home/ntnu/davidkl/GPAWTutorial/Exercises/AlOutOfPositionEnergy/aloutofpos.db", "aloutofpos.db" ] # Find the correct database for name in dbPaths: if ( os.path.isfile(name) ): db_name = name break if ( db_name == "none" ): print ("Could not find database") return # Read parameters from database con = sq.connect( db_name ) cur = con.cursor() cur.execute( "SELECT cutoff,kpts,n_atoms_to_shift,nbands,relax,gamma FROM simpar WHERE ID=?", (runID,) ) dbparams = cur.fetchall()[0] con.close() # Transfer the parameters to the params dictionary params["cutoff"] = dbparams[0] params["kpts"] = dbparams[1] params["n_atoms_to_shift"] = dbparams[2] params["nbands"] = dbparams[3] params["relax"] = dbparams[4] params["gamma"] = dbparams[5] if ( params["gamma"] ): kpts = {"size":(params["kpts"],params["kpts"],params["kpts"]), "gamma":True} else: kpts = (params["kpts"],params["kpts"],params["kpts"]) # Initialize the calculator calc = gp.GPAW( mode=gp.PW(params["cutoff"]), xc="PBE", nbands=params["nbands"], kpts=kpts ) # Initialize the atoms aluminum = build.bulk( "Al", crystalstructure="fcc" ) P = build.find_optimal_cell_shape_pure_python( aluminum.cell, 32, "sc" ) aluminum = build.make_supercell( aluminum, P ) aluminum = moveAtoms( aluminum, params["n_atoms_to_shift"], alat=4.05 ) aluminum.set_calculator( calc ) if ( params["relax"] ): logfile = "logilfe%d.log"%(runID) trajfile = "optTrajectory%d.traj"%(runID) traj = Trajectory( trajfile, 'w', aluminum ) # Optimize internal positions relaxer = BFGS( aluminum, logfile=logfile ) relaxer.attach( traj ) relaxer.run( fmax=0.05 ) # Optimize cell strain = StrainFilter( aluminum ) relaxer = BFGS( strain, logfile=logfile ) relaxer.attach( traj ) relaxer.run( fmax=0.05 ) energy = aluminum.get_potential_energy() # Add results to the database asedb = ase.db.connect( db_name ) lastID = asedb.write( aluminum, relaxed=True ) # Update the parameters in the database con = sq.connect( db_name ) cur = con.cursor() cur.execute( "UPDATE simpar SET status=?,systemID=? WHERE ID=?", ("finished",lastID,runID) ) con.commit() con.close()
def main(argv): relax_mode = "cell" # both, cell, positions system = "AlMg" runID = int(argv[0]) print("Running job: %d" % (runID)) db_paths = [ "/home/ntnu/davidkl/GPAWTutorial/CE/almg_217.db", "almg_217.db", "/home/davidkl/GPAWTutorial/CE/almg_217.db" ] for path in db_paths: if (os.path.isfile(path)): db_name = path break #db_name = "test_db.db" db = ase.db.connect(db_name) con = sq.connect(db_name) cur = con.cursor() cur.execute("SELECT value FROM text_key_values WHERE id=? AND key='name'", (runID, )) name = cur.fetchone()[0] con.close() new_run = not db.get(id=runID).key_value_pairs["started"] # Update the databse db.update(runID, started=True, converged=False) atoms = db.get_atoms(id=runID) calc = gp.GPAW(mode=gp.PW(500), xc="PBE", kpts=(4, 4, 4), nbands="120%") #calc = gp.GPAW( mode=gp.PW(500), xc="PBE", kpts=(4,4,4), nbands=-10 ) atoms.set_calculator(calc) logfile = "almg_bcc%d.log" % (runID) traj = "almg_bcc%d.traj" % (runID) trajObj = Trajectory(traj, 'w', atoms) storeBest = SaveToDB(db_name, runID, name, mode=relax_mode) volume = atoms.get_volume() try: precon = Exp(mu=1.0, mu_c=1.0) fmax = 0.025 smax = 0.003 if (relax_mode == "both"): relaxer = PreconLBFGS(atoms, logfile=logfile, use_armijo=True, precon=precon, variable_cell=True) elif (relax_mode == "positions"): relaxer = SciPyFminCG(atoms, logfile=logfile) #relaxer = BFGS( atoms, logfile=logfile ) elif (relax_mode == "cell"): str_f = StrainFilter(atoms, mask=[1, 1, 1, 0, 0, 0]) relaxer = BFGS(str_f, logfile=logfile) fmax = smax * volume relaxer.attach(trajObj) relaxer.attach(storeBest, interval=1, atoms=atoms) if (relax_mode == "both"): relaxer.run(fmax=fmax, smax=smax) else: relaxer.run(fmax=fmax) energy = atoms.get_potential_energy() if (relax_mode == "positions"): db.update(storeBest.runID, converged_force=True) elif (relax_mode == "cell"): db.update(storeBest.runID, converged_stress=True) else: db.update(storeBest.runID, converged_stress=True, converged_force=True) row = db.get(id=storeBest.runID) conv_force = row.get("converged_force", default=0) conv_stress = row.get("converged_stress", default=0) if ((conv_force == 1) and (conv_stress == 1)): db.update(storeBest.runID, converged=True) except Exception as exc: print(exc)