def concatenate_trajs(directory, traj):
"""Concantenate trajectories
Merge all the history and trajectory files
in one full trajectory of relaxation
Arguments:
directory {str} -- the directory with unfinished calculation
traj {trajectory name} -- name of trajectory file
"""
history_trajs = [
i for i in os.listdir(directory) if "history" in i
]
temp_traj = Trajectory(os.path.join(directory, "temp.traj"), "a")
for t in history_trajs:
tt = Trajectory(os.path.join(directory, t))
# Merge history trajectories without clashed last steps in each
# Since the first step and the last step in the trajectories are the same
for at in tt[:-1]:
temp_traj.write(at)
tt.close()
last_traj = Trajectory(os.path.join(directory, traj))
for at in last_traj:
temp_traj.write(at)
last_traj.close()
temp_traj.close()
os.rename(
os.path.join(directory, "temp.traj"),
os.path.join(directory, traj),
)
# Cleaning up
for i in history_trajs:
os.remove(os.path.join(directory, i))
def findConformers(self, strref=None, icsref=None):
"""
all stretches have to be the same;
"""
if strref is None or icsref is None:
stre = self.notdis[0].ic.getStretchBendTorsOop()[0][0]
ics = self.notdis[0].ic.getStretchBendTorsOop()[1]
else:
stre = strref
ics = icsref
xx = Trajectory('confs.traj', 'a')
yy = Trajectory('notconfs.traj', 'a')
cnt = 0
for i in self.notdis:
istre = i.ic.getStretchBendTorsOop()[0][0]
iics = i.ic.getStretchBendTorsOop()[1]
same = True
if len(stre) > len(istre):
same = False
else:
for j in stre:
#print j
#print i.oldn
if not (iics[j][0] == ics[j][0]
and iics[j][1] == iics[j][1]):
same = False
break
if same:
xx.write(i.atoms)
cnt += 1
print str(cnt) + ' - ' + str(i.oldn)
self.conf.append(i)
else:
yy.write(i.atoms)
def eosfit_spec(atoms, calc, rg, method="birchmurnaghan"):
from ase.eos import EquationOfState
from numpy import linspace
rootdir = os.getcwd()
if not os.path.exists('eosfit'):
os.mkdir('eosfit')
os.chdir('eosfit')
cell = atoms.get_cell()
atoms.set_calculator(calc)
traj = Trajectory('eosfit.traj', 'w')
for x in rg:
print(str(x))
atoms.set_cell(cell * x, scale_atoms=True)
atoms.get_potential_energy()
traj.write(atoms)
configs = Trajectory('eosfit.traj', 'r')
volumes = [at.get_volume() for at in configs]
energies = [at.get_potential_energy() for at in configs]
eos = EquationOfState(volumes, energies, eos=method)
v0, e0, B = eos.fit()
eos.plot('eosfit.svg')
fp = open('eosdata.dat', 'w')
fp.write('Volume\t\tEnergy')
for i in range(len(configs)):
fp.write(str(volumes[i]) + '\t' + str(energies[i]) + '\n')
os.chdir(rootdir)
def plot_energy(traj='md.traj'):
images = Trajectory(traj)
e,ei,ei_,diff = [],[],[],[]
# ir_mpnn = IRFF(atoms=images[0],
# libfile='ffield.json',
# nn=True)
# ir_mpnn.get_potential_energy(images[0])
#ir_reax = IRFF(atoms=images[0],
# libfile='ffield',
# nn=False)
#ir_reax.get_potential_energy(images[0])
#atoms = read(traj,index=-1)
#print(atoms.get_potential_energy())
#exit()
images = Trajectory('md.traj')
v = []
for i,atoms in enumerate(images):
ei.append(atoms.get_potential_energy())
# ei.append(ir_mpnn.get_potential_energy(atoms))
#ei_.append(ir_reax.get_potential_energy(atoms))
#diff.append(abs(e[-1]-ei[-1]))
#print(' * energy: ',e[-1],ei[-1],ei_[-1],diff[-1])
v.append(atoms.get_volume())
# stress = atoms.get_stress()
# print(stress)
del atoms
#print(' * mean difference: ',np.mean(diff))
#e_min = min(e)
#e_max = max(e)
#e = np.array(e) - e_min
e_min = min(ei)
ei = np.array(ei) - e_min
#e_min = min(ei_)
#ei_ = np.array(ei_) - e_min
plt.figure()
plt.ylabel(r'$Total$ $Energy$ ($eV$)')
plt.xlabel(r'$MD$ $Step$')
# plt.xlim(0,i)
# plt.ylim(0,np.max(hist)+0.01)
plt.plot(ei,alpha=0.9,
linestyle='-',# marker='o',markerfacecolor='k',markersize=5,
color='k',label='ReaxFF-MPNN')
# plt.plot(v,ei,alpha=0.9,
# linestyle='-',marker='^',markerfacecolor='none',
# markeredgewidth=1,markeredgecolor='blue',markersize=5,
# color='blue',label='IRFF')
# plt.text( 0.0, e_max, '%.3f' %e_min, fontdict={'size':10.5, 'color': 'k'})
plt.legend(loc='best',edgecolor='yellowgreen') # lower left upper right
plt.savefig('Energy.pdf',transparent=True)
plt.close()
def main(fname):
fname_out = fname.split(".")[0]
fname_out += "only_cluster.traj"
traj = Trajectory(fname, mode="r")
traj_clust = Trajectory(fname_out, mode="w")
for i, atoms in enumerate(traj):
print("{} of {}".format(i, len(traj)))
cluster = extract_cluster(atoms)
traj_clust.write(cluster)
def sel(traj='md.traj',m=3):
newt= traj.replace('.traj','_.traj')
images = Trajectory(traj)
his = TrajectoryWriter(newt,mode='w')
images = Trajectory(traj)
for i,atoms in enumerate(images):
if i%m==0:
his.write(atoms=atoms)
his.close()
def plot_gga(ax, ax1):
def murnaghan(V, E0, B0, BP, V0):
'From PRB 28,5480 (1983'
E = E0 + B0 * V / BP * \
(((V0 / V)**BP) / (BP - 1) + 1) - V0 * B0 / (BP - 1)
return E
traj = Trajectory('nagao2-r3m-gga.traj')
v = [i.get_volume() for i in traj]
e1 = np.array([i.get_total_energy() * Rydberg for i in traj])
eos_data = eos(v, e1, eos='murnaghan')
eos_data.fit()
V = np.linspace(35, 54, 100)
E = murnaghan(V, eos_data.eos_parameters[0], eos_data.eos_parameters[1],
eos_data.eos_parameters[2], eos_data.eos_parameters[3])
r3m_e = E
r3m_v = V
traj = Trajectory('nagao2-p2n1_gga.traj')
v = [i.get_volume()*0.25 for i in traj]
e1 = np.array([i.get_total_energy() * Rydberg*0.25 for i in traj])
eos_data = eos(v, e1, eos='murnaghan')
eos_data.fit()
V = np.linspace(45, 65, 100)
E = murnaghan(V, eos_data.eos_parameters[0], eos_data.eos_parameters[1],
eos_data.eos_parameters[2], eos_data.eos_parameters[3])
p2n1_e = E
p2n1_v = V
minimum = np.min([r3m_e, p2n1_e])
c = "k"
label = "R$\\bar{3}$m"
ax.plot(r3m_v, r3m_e-minimum, c=c, label=label)
c = "r"
label = "Pna$2_1$"
ax.plot(p2n1_v, p2n1_e-minimum, c=c, label=label)
ax.legend()
c = "k"
label = "R$\\bar{3}$m"
p = -1*np.gradient(r3m_e, np.diff(r3m_v)[0])
h = r3m_e-p*r3m_v
h1 = h
p1 = p
ax1.plot(p, h, c=c, label=label)
c = "r"
label = "Pna$2_1$"
p = -1*np.gradient(p2n1_e, np.diff(p2n1_v)[0])
h = p2n1_e-p*p2n1_v
h2 = h
p2 = p
ax1.plot(p, h, c=c, label=label)
ax1.legend()
return h1, h2, p1, p2
def col(traj='siesta.traj', start=0, end=20):
newt = traj.replace('.traj', '_.traj')
images = Trajectory(traj)
his = TrajectoryWriter(newt, mode='w')
images = Trajectory(traj)
for i in range(start, end):
atoms = images[i]
his.write(atoms=atoms)
his.close()
def sortraj(traj='siesta.traj'):
newt = traj[:-5] + '_.traj'
images = Trajectory(traj)
his = TrajectoryWriter(newt, mode='w')
images = Trajectory(traj)
for i in range(50):
atoms = images[i]
his.write(atoms=atoms)
his.close()
def e(i=1,j=0,k=2):
colors = ['r','b','k','y']
markers= ['s','o','^','+']
images1 = Trajectory('h2o-s1.traj')
images2 = Trajectory('h2o-s2.traj')
images3 = Trajectory('h2o-s3.traj')
images4 = Trajectory('h2o-s4.traj')
E,R,angles = [],[],[]
for images in [images1,images2,images3,images4]:
e,r = [],[]
for atoms in images:
e.append(atoms.get_potential_energy())
ri = atoms.positions[i]
rj = atoms.positions[j]
rk = atoms.positions[k]
rij= rj - ri
rjk= rk - rj
rik= rk - ri
rij2 = np.sum(np.square(rij))
rij_ = np.sqrt(rij2)
r.append(rij_)
rik2 = np.sum(np.square(rik))
rik_ = np.sqrt(rik2)
rjk2 = np.sum(np.square(rjk))
rjk_ = np.sqrt(rjk2)
cos_ = (rij2+rjk2-rik2)/(2.0*rij_*rjk_)
a = np.arccos(cos_)*180.0/3.14159
R.append(r)
E.append(e)
angles.append(a)
plt.figure()
plt.ylabel('Energy (eV)')
plt.xlabel('Radius (Angstrom)')
# plt.xlim(0,i)
# plt.ylim(0,np.max(hist)+0.01)
for i_,e in enumerate(E):
e_min = min(e)
e = np.array(e) - e_min
plt.plot(R[i_],e,alpha=0.8,
linestyle='-',marker='^',markersize=5,
color=colors[i_],label='H-O-H: %4.1f' %angles[i_])
plt.legend(loc='best',edgecolor='yellowgreen')
plt.savefig('Energy.pdf',transparent=True)
plt.close()
def test_trajectory_heterogeneous():
from ase.constraints import FixAtoms, FixBondLength
from ase.build import molecule, bulk
from ase.io.trajectory import Trajectory, get_header_data
from ase.io import read
a0 = molecule('H2O')
a1 = a0.copy()
a1.rattle(stdev=0.5)
a2 = a0.copy()
a2.set_masses()
a2.center(vacuum=2.0)
a2.rattle(stdev=0.2)
a3 = molecule('CH3CH2OH')
a4 = bulk('Au').repeat((2, 2, 2))
a5 = bulk('Cu').repeat((2, 2, 3))
# Add constraints to some of the images:
images = [a0, a1, a2, a3, a4, a5]
for i, img in enumerate(images[3:]):
img.set_constraint(FixAtoms(indices=range(i + 3)))
if i == 2:
img.constraints.append(FixBondLength(5, 6))
traj = Trajectory('out.traj', 'w')
for i, img in enumerate(images):
traj.write(img)
print(i, traj.multiple_headers)
assert traj.multiple_headers == (i >= 2)
traj.close()
rtraj = Trajectory('out.traj')
newimages = list(rtraj)
assert len(images) == len(newimages)
for i in range(len(images)):
assert images[i] == newimages[i], i
h1 = get_header_data(images[i])
h2 = get_header_data(newimages[i])
print(i, images[i])
print(h1)
print(h2)
print()
# assert headers_equal(h1, h2)
# Test append mode:
with Trajectory('out.traj', 'a') as atraj:
atraj.write(molecule('H2'))
atraj.write(molecule('H2'))
read('out.traj', index=':')
def __init__(self,
atoms,
restart=None,
logfile=None,
trajectory=None,
seed=None,
verbose=False):
Optimizer.__init__(self, atoms, restart, logfile, trajectory=None)
atoms.get_forces()
atoms.get_potential_energy()
if seed is None:
seed = np.random.randint(0, 2**31)
self.verbose = verbose
self.random_state = RandomState(seed)
self.starting_atoms = dc(atoms)
self.pe = []
self.metadata = {'seed': seed}
self.traj = [dc(atoms)]
print(self.traj[0].get_momenta())
if trajectory is not None:
self.trajectory = Trajectory(trajectory, mode='w')
self.trajectory.write(self.traj[-1])
if self.verbose:
print('Trajectory written', len(self.traj))
else:
self.trajectory = None
if verbose:
print('trajectory file', self.trajectory)
def process(self):
print("### Preprocessing atoms objects from: {}".format(
self.raw_file_names[0]))
traj = Trajectory(self.raw_file_names[0])
a2g = AtomsToGraphs(
max_neigh=self.config.get("max_neigh", 12),
radius=self.config.get("radius", 6),
dummy_distance=self.config.get("radius", 6) + 1,
dummy_index=-1,
r_energy=True,
r_forces=True,
r_distances=False,
)
data_list = []
for atoms in tqdm(
traj,
desc="preprocessing atomic features",
total=len(traj),
unit="structure",
):
data_list.append(a2g.convert(atoms))
self.data, self.slices = collate(data_list)
torch.save((self.data, self.slices), self.processed_file_names[0])
def __cleanup__(self):
""" Tries to load in structures previously
submitted to the queing system. """
confs = self.dc.get_all_candidates_in_queue()
for c in confs:
fdone = '{0}/cand{1}_done.traj'.format(self.tmp_folder, c)
if os.path.isfile(fdone) and os.path.getsize(fdone) > 0:
try:
a = []
niter = 0
while len(a) == 0 and niter < 5:
t = Trajectory(fdone, 'r')
a = [ats for ats in t]
if len(a) == 0:
time.sleep(1.)
niter += 1
if len(a) == 0:
txt = 'Could not read candidate ' + \
'{0} from the filesystem'.format(c)
raise IOError(txt)
a = a[-1]
a.info['confid'] = c
self.dc.add_relaxed_step(
a,
find_neighbors=self.find_neighbors,
perform_parametrization=self.perform_parametrization)
except IOError as e:
print(e)
def md(atoms=None,
gen='poscar.gen',
step=100,
nn=True,
ffield='ffield.json',
initT=300,
timeStep=0.1,
vdwnn=False,
print_interval=1):
irmd = IRMD(time_step=timeStep,
totstep=step,
atoms=atoms,
gen=gen,
Tmax=10000,
ro=0.8,
rmin=0.5,
initT=initT,
vdwnn=vdwnn,
print_interval=print_interval,
nn=nn,
ffield=ffield)
irmd.run()
irmd.close()
del irmd
images = Trajectory('md.traj')
# if v:
# view(images[-1]) # ,viewer='x3d'
return images
def bhopt(atoms=None,
gen='poscar.gen',
fmax=0.3,
step=100,
dr=0.5,
temperature=100,
optimizer=BFGS,
vdwnn=False,
nn=True,
v=False):
if atoms is None:
atoms = read(gen)
atoms.calc = IRFF(atoms=atoms,
libfile='ffield.json',
rcut=None,
nn=nn,
vdwnn=vdwnn)
optimizer = BasinHopping(
atoms=atoms, # the system to optimize
temperature=temperature * kB, # 'temperature' to overcome barriers
dr=dr, # maximal stepwidth
optimizer=optimizer,
fmax=fmax, # maximal force for the optimizer
trajectory="opt.traj")
optimizer.run(step)
if v:
images = Trajectory('opt.traj')
view(images[-1])
return atoms
def ple(traj='md.traj'):
images = Trajectory(traj)
ir = IRFF_NP(atoms=images[0], libfile='ffield.json', rcut=None, nn=True)
e, e_, r_ = [], [], []
for atoms in images:
# for i in range(62):
# atoms = images[i]
e.append(atoms.get_potential_energy())
ir.calculate(atoms)
# r_.append(ir.r[atomi][atomj])
e_.append(ir.E)
fig, ax = plt.subplots()
plt.plot(e,
label=r'$DFT$ ($SIESTA$)',
color='red',
markeredgewidth=1,
ms=5,
alpha=0.8,
linewidth=2,
linestyle='-')
# plt.plot(e,label=r'$Potential$ $Energy$', color='red',
# marker='^',markerfacecolor='none',
# markeredgewidth=1,
# ms=5,alpha=0.8,
# linewidth=1, linestyle='-')
plt.legend(loc='best', edgecolor='yellowgreen')
plt.savefig('popeng.svg', transparent=True)
plt.close()
def compare_trajectory(self, i_traj, calc, tables, i_par):
"""
Calculate the energies for the frames in the trajectory
and plot them.
"""
frames = []
energies = []
trajectory = Trajectory(self.trajectories[i_traj])
for i, image in enumerate(trajectory):
e_tb = None
try:
atoms = Atoms(image)
c = copy(calc)
c.tables = tables
atoms.set_calculator(c)
e_tb = atoms.get_potential_energy()
except Exception as ex:
print(ex, file=self.txt)
if e_tb != None:
energies.append(e_tb)
frames.append(i)
delta_E = self.norm_to_isolated_atoms(trajectory[0])
for i in range(len(energies)):
energies[i] += delta_E
self.plot(frames, energies, i_traj, tables, i_par)
def __init__(self,
slab: Atoms,
adsorbate: Atoms,
bonds: List[Tuple[int, int]],
dists: List[float],
initial_height: float = 1.0,
weight: float = 1.0,
scale: float = 1.0,
trajectory: str = None) -> None:
self.slab = slab
self.adsorbate = adsorbate
zmax_slab = np.max(self.slab.positions[:, 2])
zmin_ads = np.min(self.adsorbate.positions[:, 2])
self.adsorbate.positions[:, 2] += initial_height + zmax_slab - zmin_ads
self.ads_ref = self.slab + self.adsorbate
self.bonds = bonds
self.dists = dists
self.weight = weight
self.scale = scale
self.trajectory = trajectory
if self.trajectory is not None:
self.trajectory = Trajectory(self.trajectory, 'w', self.ads_ref)
def main():
args = get_args()
if not os.path.exists(args.filename):
exit(f'Trajectory file {args.filename} doesn\'t exist')
if not args.filename.endswith('.traj'):
exit('Trajectory must be an ASE .traj file')
out_filename = args.filename.replace('.traj', '.xyz')
# Make sure the file is empty
open(out_filename, 'w').close()
# Convert the trajectory to a .xyz file
read_traj = Trajectory(args.filename, 'r')
for timestep in range(len(read_traj)):
if timestep % args.stride == 0:
atoms = read_traj[timestep]
if args.nowrap is False:
atoms.wrap()
write(out_filename, atoms, format='xyz', append=True)
return None
def bde(ffield='ffield.json', nn='T', gen='poscar.gen', traj='C2H4.traj'):
images = Trajectory(traj)
atoms = images[0]
nn_ = True if nn == 'T' else False
ir = IRFF_NP(atoms=atoms, libfile=ffield, rcut=None, nn=nn_)
natom = ir.natom
Empnn, Esiesta = [], []
eb, eb_ = [], []
for atoms in images:
ir.calculate(atoms)
Empnn.append(ir.E)
Esiesta.append(atoms.get_potential_energy())
# eb.append(ir.ebond[i][j])
fig, ax = plt.subplots()
plt.plot(Empnn[0:14],
label=r'$E_{MPNN}$',
color='blue',
linewidth=2,
linestyle='-.')
plt.plot(Esiesta[0:14],
label=r'$E_{SIESTA}$',
color='r',
linewidth=2,
linestyle='-')
plt.legend(loc='best', edgecolor='yellowgreen')
plt.savefig('Ecompare.pdf')
plt.show()
plt.close()
def getTrajactory(self):
atoms = self.xv_to_atoms(self.label + '.XV')
atoms.pbc = [True, True, True]
filename = 'Trajectory'
atomsList = []
with open(self.label + '.MD_CAR') as f:
blockLine = self.numAtom + 7
context = f.readlines()
for step in range(self.curStep - 1):
output = context[step * blockLine:(step + 1) * blockLine]
coodinates = np.array([[
float(value.replace('\n', '')) for value in line.split()
] for line in output[7:]])
atomsCurrent = atoms.copy()
atomsCurrent.set_scaled_positions(coodinates)
atomsList.append(atomsCurrent)
from ase.io import write
write(filename, atomsList, 'traj')
from ase.io.trajectory import Trajectory
traj = Trajectory(filename)
return traj
def SinglePointEnergies(traj, label='aimd', frame=50, cpu=4):
his = TrajectoryWriter(label + '.traj', mode='w')
images = Trajectory(traj)
tframe = len(images)
E = []
if tframe > frame:
ind_ = np.linspace(0, tframe, num=frame, dtype=np.int32)
for i in range(tframe):
if tframe > frame:
if i in ind_:
atoms = images[i]
else:
continue
else:
atoms = images[i]
e_ = atoms.get_potential_energy()
atoms_ = single_point(atoms, cpu=cpu)
e = atoms_.get_potential_energy()
his.write(atoms=atoms_)
print('- Energies from MLP: %9.5f DFT: %9.5f' % (e_, e))
E.append(e)
his.close()
images = None
return E
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 opt(atoms=None,
gen='poscar.gen',
fmax=0.3,
step=100,
optimizer=BFGS,
vdwnn=False,
nn=True):
if atoms is None:
atoms = read(gen)
atoms.calc = IRFF(atoms=atoms,
libfile='ffield.json',
rcut=None,
nn=nn,
vdwnn=vdwnn)
def check(atoms=atoms):
epot_ = atoms.get_potential_energy()
r = atoms.calc.r.detach().numpy()
i_ = np.where(np.logical_and(r < 0.5, r > 0.0001))
n = len(i_[0])
try:
assert not np.isnan(epot_), '- Energy is NaN!'
except:
atoms.write('poscarN.gen')
raise ValueError('- Energy is NaN!')
optimizer_ = optimizer(atoms, trajectory="opt.traj")
optimizer_.attach(check, interval=1)
optimizer_.run(fmax, step)
images = Trajectory('opt.traj')
# view(images[-1])
return images
def replay_trajectory(self, traj):
"""Initialize hessian from old trajectory."""
self.replay = True
closelater = None
if isinstance(traj, str):
from ase.io.trajectory import Trajectory
traj = closelater = Trajectory(traj, 'r')
try:
r0 = None
g0 = None
for i in range(0, len(traj) - 1):
r = traj[i].get_positions().ravel()
g = -traj[i].get_forces().ravel() / self.alpha
self.update(r, g, r0, g0, self.p)
self.p = -np.dot(self.H, g)
r0 = r.copy()
g0 = g.copy()
self.r0 = r0
self.g0 = g0
finally:
if closelater is not None:
closelater.close()
def eos(self, atoms, name):
args = self.args
traj = Trajectory(self.get_filename(name, 'traj'), 'w', atoms)
N, eps = args.equation_of_state.split(',')
N = int(N)
eps = float(eps) / 100
strains = np.linspace(1 - eps, 1 + eps, N)
v1 = atoms.get_volume()
volumes = strains**3 * v1
energies = []
cell1 = atoms.cell
for s in strains:
atoms.set_cell(cell1 * s, scale_atoms=True)
energies.append(atoms.get_potential_energy())
traj.write(atoms)
traj.close()
eos = EquationOfState(volumes, energies, args.eos_type)
v0, e0, B = eos.fit()
atoms.set_cell(cell1 * (v0 / v1)**(1 / 3), scale_atoms=True)
data = {
'volumes': volumes,
'energies': energies,
'fitted_energy': e0,
'fitted_volume': v0,
'bulk_modulus': B,
'eos_type': args.eos_type
}
return data
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 test_md(factory):
# XXX ugly hack
ver = factory.factory.version()
if LooseVersion(ver) < '3.8':
pytest.skip('No stress tensor until openmx 3.8+')
bud = Atoms('CH4',
np.array([[0.000000, 0.000000, 0.100000],
[0.682793, 0.682793, 0.682793],
[-0.682793, -0.682793, 0.68279],
[-0.682793, 0.682793, -0.682793],
[0.682793, -0.682793, -0.682793]]),
cell=[10, 10, 10])
calc = factory.calc(
label='ch4',
xc='GGA',
energy_cutoff=300 * Ry,
convergence=1e-4 * Ha,
# Use 'C_PBE19' and 'H_PBE19' for version 3.9
definition_of_atomic_species=[['C', 'C5.0-s1p1', 'C_PBE13'],
['H', 'H5.0-s1', 'H_PBE13']],
kpts=(1, 1, 1),
eigensolver='Band')
bud.calc = calc
with Trajectory('example.traj', 'w', bud) as traj:
ucf = UnitCellFilter(bud,
mask=[True, True, False, False, False, False])
dyn = QuasiNewton(ucf)
dyn.attach(traj.write)
dyn.run(fmax=0.1)
bud.get_potential_energy()
def get_bulk(name, proto):
# Get bulk properties
dir_root = os.path.join("../../data/2D-bulk/{}-{}".format(name, proto))
gpw_file = os.path.join(dir_root, "gs.gpw")
traj_file = os.path.join(dir_root, "{}-{}_relax.traj".format(name, proto))
eps_file = os.path.join(dir_root, "eps_df.npz")
if (not os.path.exists(gpw_file)) or (not os.path.exists(eps_file)):
return None
else:
try:
d = Trajectory(traj_file)[-1].cell[-1][-1]
except Exception:
print(Exception)
c_atoms = read(gpw_file)
# calc = GPAW(gpw_file)
d = c_atoms.cell[-1][-1]
# d = calc.get_atoms().cell[-1][-1]
f = numpy.load(eps_file)
eps_xx = f["eps_x"][0].real
eps_zz = f["eps_z"][0].real
calc = GPAW(gpw_file)
try:
E_GGA, *_ = bandgap(calc)
except Exception:
E_GGA = None
return d, eps_xx, eps_zz, E_GGA
