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)
