def read_local(filename, state_number=None, mode=None):
f = open(filename, 'r')
local_minimum = {}
ener = []
cycle = 0
while True:
elements = []
positions = []
line = f.readline()
if not line:
break
if cycle == 0:
atom_numb = int(line.split()[0])
line = f.readline()
energy = (float(line.split()[0]))
#read one particular structure assinged by state_number
for i in range(atom_numb):
line = f.readline()
fields = line.split()
elements.append(fields[0])
positions.append([float(fields[j + 1]) for j in range(3)])
elements = np.array(elements)
positions = np.array(positions)
ener.append(energy)
p = Atoms(elements, positions=positions)
p.set_cell([[20., 0, 0], [0, 20., 0], [0, 0, 20.]], scale_atoms=False)
p.set_pbc((True, True, True))
cm = p.get_center_of_mass()
cm_o = np.array([0., 0., 0.])
p.translate(cm_o - cm)
image = [p, energy]
local_minimum[cycle] = [image, []]
cycle += 1
f.close()
return local_minimum
def sphere(atomlist, fill_factor=0.74, radius=None, cell=None):
"""Generates a random sphere of particles given an
atomlist and radius. If radius is None, one is
automatically estimated. min_dist and tries_b4_expand
are parameters that govern how stricly the proximity
of atoms are enforced.
"""
if radius is None:
radius = get_particle_radius(atomlist, fill_factor)
# Create a list of random order of the atoms
chemical_symbols = []
for atom in atomlist:
chemical_symbols += [atom[0]] * atom[1]
random.shuffle(chemical_symbols)
unit_vec = np.array([random_three_vector() for i in range(len(chemical_symbols))])
D = radius * np.random.sample(size=len(chemical_symbols)) ** (1.0/3.0)
positions = np.array([D]).T * unit_vec
indiv = Atoms(symbols=chemical_symbols, positions=positions)
if cell is not None:
indiv.set_cell(cell)
cell_center = np.sum(indiv.get_cell(), axis=1) / 2.0
indiv.translate(indiv.get_center_of_mass() + cell_center)
indiv.set_pbc(True)
return indiv
def test_distance():
import itertools
import numpy as np
from ase import Atoms, Atom
from ase.geometry import distance
# artificial structure
org = Atoms('COPNS',
[[-1.75072, 0.62689, 0.00000], [0.58357, 2.71652, 0.00000],
[-5.18268, 1.36522, 0.00000], [-1.86663, -0.77867, 2.18917],
[-1.80586, 0.20783, -2.79331]])
maxdist = 3.0e-13
# translate
for dx in range(3, 10, 2):
new = org.copy()
new.translate([dx / np.sqrt(2), -dx / np.sqrt(2), 0])
dist = distance(org, new, True)
dist2 = distance(org, new, False)
print('translation', dx, '-> distance', dist)
assert dist < maxdist
assert dist == dist2
# rotate
for axis in ['x', '-y', 'z', np.array([1, 1, 1] / np.sqrt(3))]:
for rot in [20, 200]:
new = org.copy()
new.translate(-new.get_center_of_mass())
new.rotate(rot, axis)
dist = distance(org, new, True)
dist2 = distance(org, new, False)
print('rotation', axis, ', angle', rot, '-> distance', dist)
assert dist < maxdist
assert dist == dist2
if 0:
# reflect
new = Atoms()
cm = org.get_center_of_mass()
for a in org:
new.append(Atom(a.symbol, -(a.position - cm)))
dist = distance(org, new)
print('reflected -> distance', dist)
# permute
for i, a in enumerate(org):
if i < 3:
a.symbol = 'H'
for indxs in itertools.permutations(range(3)):
new = org.copy()
for c in range(3):
new[c].position = org[indxs[c]].position
dist = distance(org, new)
print('permutation', indxs, '-> distance', dist)
assert dist < maxdist
def radius_of_gyration(atoms: Atoms):
"""Compute the radius of gyration of a molecule
Method: http://www.charmm-gui.org/?doc=lecture&module=scientific&lesson=10
"""
cm = atoms.get_center_of_mass()
disp = np.linalg.norm(atoms.get_positions() - cm, 2, axis=1)
m = atoms.get_masses()
return np.dot(m, disp) / np.sum(m)
def get_ASE_atoms(self, centered=True):
atom_positions = list()
atomic_symbols = list()
for lattice_index in self.atoms.get_indices():
atom_positions.append(self.lattice.get_cartesian_position_from_index(lattice_index))
atomic_symbols.append(self.atoms.get_symbol(lattice_index))
atoms = Atoms(positions=atom_positions, symbols=atomic_symbols)
if centered:
COM = atoms.get_center_of_mass()
return Atoms(positions=[position - COM for position in atom_positions], symbols=atomic_symbols)
else:
return atoms
def test_com(zlength):
"""Test that atoms.get_center_of_mass(scaled=True) works"""
d = 1.142
a = Atoms('CO', positions=[(2, 0, 0), (2, -d, 0)], pbc=True)
a.set_cell(np.array(((4, -4, 0), (0, 5.657, 0), (0, 0, zlength))))
def array_almost_equal(a1, a2, tol=np.finfo(type(1.0)).eps):
return (np.abs(a1 - a2) < tol).all()
scaledref = np.array((0.5, 0.23823622, 0.))
assert array_almost_equal(a.get_center_of_mass(scaled=True),
scaledref,
tol=1e-8)
def get_obj_funcs(dir_list, v, b, f):
#define initial residual to be added for each .xyz file
residual = []
surf_E = 0
energ = []
for j, dir in enumerate(tqdm(dir_list, leave=False)):
#move into particular folder
chdir(dir)
#get & separate coordinates
df = read_csv(dir + '.xyz',
header=2,
names=['type', 'x', 'y', 'z'],
sep='\s+')
coords = df[['x', 'y', 'z']]
types = df['type']
surf_z = coords['z'].iloc[0]
n = len(coords['z'])
#separates molecule and surface by checking z coordinate
for i in range(n):
if df['z'].iloc[i] != surf_z:
surf_coords = coords.iloc[:i, :]
mol_coords = coords.iloc[i:, :]
surf_types = types.iloc[:i]
mol_types = types.iloc[i:]
break
#create Atoms objects for surface and molecule
surf = Atoms(positions=surf_coords.values, symbols=surf_types.values)
mol = Atoms(positions=mol_coords.values, symbols=mol_types.values)
#only need to calculate surface energy once, b/c identical from trial-to-trial
if j == 0:
surf_E = get_surface_energy(f, surf.positions)
#calculate energy for each config.
energ.append(
get_energy(f, [mol.get_center_of_mass()], surf.positions) + surf_E)
rp1 = (1 / 2) * (v[j] - energ[j])**2
residual.append(rp1)
#print(rp1)
#go into bulk directory
chdir('..')
return residual
def truncated_octahedron(self,
height,
cutoff,
stoichiometry,
lattice_constant=3.9,
alloy=False):
octa = Octahedron('Pt',
height,
cutoff,
latticeconstant=lattice_constant,
alloy=alloy)
atoms = Atoms(octa.symbols, octa.positions)
com = atoms.get_center_of_mass()
atoms.positions -= com
self.add_atoms(atoms, recompute_neighbor_list=False)
self.random_ordering(stoichiometry)
self.construct_neighbor_list()
def sphere(atomlist, cell, fill_factor=0.74, radius=None):
"""Generates a random sphere of particles given an
atomlist and radius.
Parameters
----------
atomlist : list
A list of [sym, n] pairs where sym is the chemical symbol
and n is the number of of sym's to include in the individual
cell : list
The x, y, and z dimensions of the cell which holds the particle.
fill_factor : float
How densely packed the sphere should be. Ranges from 0 to 1.
radius : float
The radius of the sphere. If None, estimated from the
atomic radii
"""
if radius is None:
radius = get_particle_radius(atomlist, fill_factor)
# Create a list of random order of the atoms
chemical_symbols = []
for atom in atomlist:
chemical_symbols += [atom[0]] * atom[1]
random.shuffle(chemical_symbols)
unit_vec = np.array([random_three_vector() for i in range(len(chemical_symbols))])
D = radius * np.random.sample(size=len(chemical_symbols)) ** (1.0/3.0)
positions = np.array([D]).T * unit_vec
indiv = Atoms(symbols=chemical_symbols, positions=positions)
if cell is not None:
indiv.set_cell(cell)
cell_center = np.sum(indiv.get_cell(), axis=1) / 2.0
indiv.translate(indiv.get_center_of_mass() + cell_center)
indiv.set_pbc(True)
return indiv
#create an Atoms object of the surface unit cell
surface = Atoms(positions=coords, symbols=types)
#find box dimensions
x_box = max(coords[0]) - min(coords[0])
z_box = box[2]
y_box = max(coords[1]) - min(coords[1]) + b * sin(gamma) - vec[1]
#write to file to be used by simulation
box_file = open('box.txt', 'w')
box_file.write(str(x_box) + '\n' + str(y_box) + '\n' + str(z_box))
box_file.close()
#line up COMs, "zero" the system
shift = surface.get_center_of_mass() - mol.get_center_of_mass()
#shift each coordinate (ASE translate functionality is bad, IMO)
translated = np.empty(mol.positions.shape)
for i in range(len(mol.positions)):
translated[i] = np.add(mol.positions[i], shift)
mol.set_positions(translated)
#generate configurations
print('files to be generated:')
num = int(input())
#create directory, save name of directory for individual .xyz files
mkdir(dir_name)
#copy the bash script, input file, slurm submission file
def get_defect_indiv_random(Optimizer):
"""
Function to generate a structopt Individual class structure with a defect structure.
Inputs:
Optimizer = structopt Optimizer class object
Outputs:
individ = structopt Individual class object containing defect structure data
"""
#Initialize Bulk - Generate or load positions of bulk solid
if not Optimizer.solidbulk:
if 'Island_Method' not in Optimizer.algorithm_type:
outfilename = os.path.join(
os.path.join(os.getcwd(), Optimizer.filename), 'Bulkfile.xyz')
else:
from mpi4py import MPI
rank = MPI.COMM_WORLD.Get_rank()
outfilename = os.path.join(
os.path.join(os.getcwd(),
Optimizer.filename + '-rank' + repr(rank)),
'Bulkfile.xyz')
if Optimizer.evalsolid:
if Optimizer.parallel:
from MAST.structopt.tools.setup_calculator import setup_calculator
Optimizer.calc = setup_calculator(Optimizer)
bulk1, PureBulkEnpa, stro = gen_solid(Optimizer.solidfile,
Optimizer.solidcell,
outfilename, Optimizer.calc,
Optimizer.calc_method)
Optimizer.output.write(stro)
else:
bulk1 = gen_solid(Optimizer.solidfile, Optimizer.solidcell,
outfilename)
PureBulkEnpa = 0
natomsbulk = len(bulk1)
Optimizer.solidbulk = bulk1.copy()
Optimizer.purebulkenpa = PureBulkEnpa
Optimizer.natomsbulk = natomsbulk
# Identify nearby atoms for region 2 inclusion
bulk = Optimizer.solidbulk.copy()
bulkcom = bulk.get_center_of_mass()
bulk.translate(-bulkcom)
if Optimizer.sf != 0:
bulk.append(Atom(position=[0, 0, 0]))
nbulk = Atoms(pbc=True, cell=bulk.get_cell())
nr2 = Atoms(pbc=True, cell=bulk.get_cell())
for i in range(len(bulk) - 1):
dist = bulk.get_distance(-1, i)
if dist <= Optimizer.sf:
nr2.append(bulk[i])
else:
nbulk.append(bulk[i])
else:
nbulk = bulk.copy()
nr2 = Atoms(pbc=True, cell=bulk.get_cell())
#Update atom list with atoms in region 2
natlist = []
for sym, c, m, u in Optimizer.atomlist:
atsym = [atm for atm in nr2 if atm.symbol == sym]
natlist.append((sym, len(atsym), m, u))
# Generate random individual and region 2
if 'sphere' in Optimizer.generate_flag:
ind = gen_pop_sphere(Optimizer.atomlist, Optimizer.size)
elif 'dumbbell' in Optimizer.generate_flag:
ind = Atoms(cell=[Optimizer.size for i in range(3)], pbc=True)
for sym, c, m, u in Optimizer.atomlist:
if c > 0:
dums = generate_dumbbells(c,
dumbbellsym=sym,
nindiv=1,
solid=Optimizer.solidbulk,
size=Optimizer.size)[0]
ind.extend(dums)
else:
ind = gen_pop_box(Optimizer.atomlist, Optimizer.size)
nnr2 = gen_pop_sphere(natlist, Optimizer.sf * 2.0)
nnr2.translate([-Optimizer.sf, -Optimizer.sf, -Optimizer.sf])
nnr2.set_pbc(True)
nnr2.set_cell(bulk.get_cell())
# Initialize class individual with known values
individ = Individual(ind)
individ.purebulkenpa = Optimizer.purebulkenpa
individ.natomsbulk = Optimizer.natomsbulk
# Combine individual with R2
icom = ind.get_center_of_mass()
ind.translate(-icom)
ind.extend(nnr2)
ind.set_pbc(True)
ind.set_cell(bulk.get_cell())
# Recenter structure
nbulk.translate(bulkcom)
ind.translate(bulkcom)
individ[0] = ind.copy()
individ.bulki = nbulk.copy()
individ.bulko = nbulk.copy()
bulk = nbulk.copy()
bul = bulk.copy()
for atm in individ[0]:
bul.append(atm)
indices = []
for sym, c, m, u in Optimizer.atomlist:
if c < 0:
if Optimizer.randvacst:
alist = [one for one in bul if one.symbol == sym]
count = abs(c)
while count > 0:
indices.append(random.choice(alist).index)
count -= 1
else:
pos = individ[0][0:Optimizer.natoms].get_center_of_mass()
count = abs(c)
bul.append(Atom(position=pos))
alist = [one for one in bul if one.symbol == sym]
alistd = [(bul.get_distance(len(bul) - 1,
one.index), one.index)
for one in alist]
alistd.sort(reverse=True)
bul.pop()
while count > 0:
idx = alistd.pop()[1]
indices.append(idx)
count -= 1
if len(indices) != 0:
nbulklist = [
at for at in bul
if at.index not in indices and at.index < len(bulk)
]
nalist = [
at for at in bul
if at.index not in indices and at.index >= len(bulk)
]
bulkn = Atoms(cell=bulk.get_cell(), pbc=True)
for atm in nbulklist:
bulkn.append(atm)
individ.bulki = bulkn.copy()
individ.bulko = bulkn.copy()
newind = Atoms()
for atm in nalist:
newind.append(atm)
newind.set_cell(individ[0].get_cell())
newind.set_pbc(True)
individ[0] = newind
return individ
def get_defect_indiv_random(Optimizer):
"""
Function to generate a structopt Individual class structure with a defect structure.
Inputs:
Optimizer = structopt Optimizer class object
Outputs:
individ = structopt Individual class object containing defect structure data
"""
#Initialize Bulk - Generate or load positions of bulk solid
if not Optimizer.solidbulk:
if 'Island_Method' not in Optimizer.algorithm_type:
outfilename = os.path.join(os.path.join(os.getcwd(),Optimizer.filename),'Bulkfile.xyz')
else:
from mpi4py import MPI
rank = MPI.COMM_WORLD.Get_rank()
outfilename = os.path.join(os.path.join(os.getcwd(),Optimizer.filename+'-rank'+repr(rank)),'Bulkfile.xyz')
if Optimizer.evalsolid:
if Optimizer.parallel:
from StructOpt.tools.setup_energy_calculator import setup_energy_calculator
Optimizer.calc = setup_energy_calculator(Optimizer)
bulk1, PureBulkEnpa, stro = gen_solid(Optimizer.solidfile,
Optimizer.solidcell,outfilename,Optimizer.calc,Optimizer.calc_method)
Optimizer.output.write(stro)
else:
bulk1 = gen_solid(Optimizer.solidfile,Optimizer.solidcell,outfilename)
PureBulkEnpa = 0
natomsbulk = len(bulk1)
Optimizer.solidbulk = bulk1.copy()
Optimizer.purebulkenpa = PureBulkEnpa
Optimizer.natomsbulk = natomsbulk
# Identify nearby atoms for region 2 inclusion
bulk = Optimizer.solidbulk.copy()
bulkcom = bulk.get_center_of_mass()
bulk.translate(-bulkcom)
if Optimizer.sf != 0:
bulk.append(Atom(position=[0,0,0]))
nbulk = Atoms(pbc=True, cell=bulk.get_cell())
nr2 = Atoms(pbc=True, cell=bulk.get_cell())
for i in range(len(bulk)-1):
dist = bulk.get_distance(-1,i)
if dist <= Optimizer.sf:
nr2.append(bulk[i])
else:
nbulk.append(bulk[i])
else:
nbulk = bulk.copy()
nr2 = Atoms(pbc=True, cell=bulk.get_cell())
#Update atom list with atoms in region 2
natlist = []
for sym,c,m,u in Optimizer.atomlist:
atsym = [atm for atm in nr2 if atm.symbol==sym]
natlist.append((sym,len(atsym),m,u))
# Generate random individual and region 2
if 'sphere' in Optimizer.generate_flag:
ind = gen_pop_sphere(Optimizer.atomlist,Optimizer.size)
elif 'dumbbell' in Optimizer.generate_flag:
ind = Atoms(cell=[Optimizer.size for i in range(3)], pbc=True)
for sym,c,m,u in Optimizer.atomlist:
if c > 0:
dums = generate_dumbbells(c, dumbbellsym=sym, nindiv=1, solid = Optimizer.solidbulk, size=Optimizer.size)[0]
ind.extend(dums)
else:
ind = gen_pop_box(Optimizer.atomlist,Optimizer.size)
nnr2 = gen_pop_sphere(natlist, Optimizer.sf*2.0)
nnr2.translate([-Optimizer.sf,-Optimizer.sf,-Optimizer.sf])
nnr2.set_pbc(True)
nnr2.set_cell(bulk.get_cell())
# Initialize class individual with known values
individ = Individual(ind)
individ.purebulkenpa = Optimizer.purebulkenpa
individ.natomsbulk = Optimizer.natomsbulk
# Combine individual with R2
icom = ind.get_center_of_mass()
ind.translate(-icom)
ind.extend(nnr2)
ind.set_pbc(True)
ind.set_cell(bulk.get_cell())
# Recenter structure
nbulk.translate(bulkcom)
ind.translate(bulkcom)
individ[0] = ind.copy()
individ.bulki = nbulk.copy()
individ.bulko = nbulk.copy()
bulk = nbulk.copy()
bul = bulk.copy()
for atm in individ[0]:
bul.append(atm)
indices = []
for sym,c,m,u in Optimizer.atomlist:
if c < 0:
if Optimizer.randvacst:
alist = [one for one in bul if one.symbol==sym]
count = abs(c)
while count > 0:
indices.append(random.choice(alist).index)
count -= 1
else:
pos = individ[0][0:Optimizer.natoms].get_center_of_mass()
count = abs(c)
bul.append(Atom(position=pos))
alist = [one for one in bul if one.symbol==sym]
alistd = [(bul.get_distance(len(bul)-1,one.index),one.index)
for one in alist]
alistd.sort(reverse=True)
bul.pop()
while count > 0:
idx = alistd.pop()[1]
indices.append(idx)
count-=1
if len(indices) !=0:
nbulklist = [at for at in bul if at.index not in indices and at.index<len(bulk)]
nalist = [at for at in bul if at.index not in indices and at.index>=len(bulk)]
bulkn = Atoms(cell=bulk.get_cell(),pbc=True)
for atm in nbulklist:
bulkn.append(atm)
individ.bulki = bulkn.copy()
individ.bulko = bulkn.copy()
newind = Atoms()
for atm in nalist:
newind.append(atm)
newind.set_cell(individ[0].get_cell())
newind.set_pbc(True)
individ[0] = newind
return individ
return dr
if __name__ == '__main__':
import os
import numpy as np
import numpy.linalg as la
from ase.calculators import mopac
from ase import Atoms
import pybel
os.chdir('../test')
MOPAC = os.path.join(os.getcwd(), 'MOPAC')
os.environ['MOPAC_LICENSE'] = MOPAC
os.environ['LD_LIBRARY_PATH'] = MOPAC
mopac_calc = mopac.MOPAC()
mopac_calc.command = 'MOPAC/MOPAC2016.exe PREFIX.mop 2> /dev/null'
mopac_calc.set(method='pm3')
mol = next(pybel.readfile('xyz', 'ts2.xyz'))
atoms = Atoms(numbers=[a.atomicnum for a in mol.atoms],
positions=[a.coords for a in mol.atoms])
atoms.set_positions(atoms.positions - atoms.get_center_of_mass())
atoms.set_calculator(mopac_calc)
irccalc = IRC(atoms, stride=0.15, mw=True, forward=True, trajectory='ts1.traj')
for _ in irccalc.run():
pass
"""Test that atoms.get_center_of_mass(scaled=True) works"""
import numpy as np
from ase import Atoms
d = 1.142
a = Atoms('CO', positions=[(2, 0, 0), (2, -d, 0)], pbc=True)
a.set_cell(np.array(((4, -4, 0), (0, 5.657, 0), (0, 0, 10))))
def array_almost_equal(a1, a2, tol=np.finfo(type(1.0)).eps):
return (np.abs(a1 - a2) < tol).all()
scaledref = np.array((0.5, 0.23823622, 0.))
assert array_almost_equal(a.get_center_of_mass(scaled=True),
scaledref,
tol=1e-8)
# rotate
for axis in ['x', '-y', 'z', np.array([1, 1, 1] / np.sqrt(3))]:
for rot in [20, 200]:
new = org.copy()
new.translate(-new.get_center_of_mass())
new.rotate(axis, np.pi * rot / 180)
dist = distance(org, new, True)
dist2 = distance(org, new, False)
print('rotation', axis, ', angle', rot, '-> distance', dist)
assert dist < maxdist
assert dist == dist2
if 0:
# reflect
new = Atoms()
cm = org.get_center_of_mass()
for a in org:
new.append(Atom(a.symbol, -(a.position - cm)))
dist = distance(org, new)
print('reflected -> distance', dist)
# permute
for i, a in enumerate(org):
if i < 3:
a.symbol = 'H'
if hasattr(itertools, 'permutations'):
for indxs in itertools.permutations(range(3)):
new = org.copy()
for c in range(3):
new[c].position = org[indxs[c]].position
# rotate
for axis in ['x', '-y', 'z', np.array([1, 1, 1] / np.sqrt(3))]:
for rot in [20, 200]:
new = org.copy()
new.translate(-new.get_center_of_mass())
new.rotate(rot, axis)
dist = distance(org, new, True)
dist2 = distance(org, new, False)
print('rotation', axis, ', angle', rot, '-> distance', dist)
assert dist < maxdist
assert dist == dist2
if 0:
# reflect
new = Atoms()
cm = org.get_center_of_mass()
for a in org:
new.append(Atom(a.symbol, -(a.position - cm)))
dist = distance(org, new)
print('reflected -> distance', dist)
# permute
for i, a in enumerate(org):
if i < 3:
a.symbol = 'H'
for indxs in itertools.permutations(range(3)):
new = org.copy()
for c in range(3):
new[c].position = org[indxs[c]].position
dist = distance(org, new)
# Fill up HCP lattice until N z_coords
count = 0
for l in range(layers):
for i in range(int(np.ceil(np.sqrt(n)))):
for j in range(int(np.ceil(np.sqrt(n)))):
if count >= N:
break
# Randomise angles
phi = 180.*random()
theta = 180.*random()
psi = 180.*random()
# Arrange in HCP arrangement with minor random x and y displacement
x = h2o_xy * (i - 0.01*(random() - 0.5)*0 + (1+(-1)**j+(-1)**l)/4.)
y = h2o_xy * (j - 0.01*(random() - 0.5)*0 + (1+(-1)**l)/4.)
z = c / 2. + ((1. - layers) / 2. + l) * h2o_z
offset = np.array([x, y, z])
h2o = Atoms('OH2', positions=pos+offset)
Atoms.euler_rotate(h2o, phi, theta, psi,
center=h2o.get_center_of_mass())
atoms += h2o
count += 1
atoms.set_cell([a, a, c])
atoms.set_pbc(1)
io.write('test.xyz', atoms)
io.write('test.pdb', atoms)
if ion == 'A':
lhs.extend(pf6)
elif ion == 'C':
lhs.extend(bmim)
for ion in r_ions:
if ion == 'A':
rhs.extend(pf6)
elif ion == 'C':
rhs.extend(bmim)
lhs.set_cell(bmim_pf6_opt.cell)
rhs.set_cell(bmim_pf6_opt.cell)
#rhs.rotate(v = 'y' , a = 180.0, center = 'COM' )
rhs.translate(
[0.0, 0.0, 2 * abs(zlen / 2.0 - rhs.get_center_of_mass()[2])])
lhs.center(axis=(0, 1))
rhs.center(axis=(0, 1))
if lshift != 0.0:
lhs.center(axis=2, about=electrode.get_center_of_mass())
lhs.translate([0.0, 0.0, lshift])
if add_electrode and too_close(lhs + electrode, 1.0):
(lhs + electrode).write('lhs_positions.vasp')
print('LHS ions are too close to the electrode')
sys.exit()
if rshift != 0.0:
rhs.center(axis=2, about=electrode.get_center_of_mass())
rhs.translate([0.0, 0.0, rshift])
def random_replacement(indiv, Optimizer):
"""Move function to replace selection of atoms with randomly generated group
Inputs:
indiv = Individual class object to be altered
Optimizer = Optimizer class object with needed parameters
Outputs:
indiv = Altered Individual class object
"""
if 'MU' in Optimizer.debug:
debug = True
else:
debug = False
if Optimizer.structure=='Defect':
if Optimizer.isolate_mutation:
atms,indb,vacant,swap,stro = find_defects(indiv[0],Optimizer.solidbulk,0)
else:
atms = indiv[0].copy()
else:
atms=indiv[0].copy()
nat=len(atms)
if nat != 0:
#Select number of atoms to replace
if nat<=1:
natrep2=1
natrep1=0
elif nat<=5:
natrep2=2
natrep1=0
else:
natrep1=random.randint(1,nat/2)
while True:
natrep2=random.randint(2,nat/2)
if natrep2 != natrep1:
break
natrep=abs(natrep2 - natrep1)
#Select random position in cluster
maxcell = numpy.maximum.reduce(atms.get_positions())
mincell = numpy.minimum.reduce(atms.get_positions())
pt=[random.uniform(mincell[0],maxcell[0]),random.uniform(mincell[1],maxcell[1]),random.uniform(mincell[2],maxcell[2])]
#Get distance of atoms from random point
atpt=Atom(position=pt)
atms.append(atpt)
dist=[]
for i in range(len(atms)-1):
dist.append(atms.get_distance(i,len(atms)-1))
atms.pop()
dlist=zip(dist,atms)
dlist=sorted(dlist, key=lambda one: one[0], reverse=True)
# Select atoms closest to random point
atmsr=Atoms()
indexlist=[]
for i in range(natrep):
atmsr.append(dlist[i][1])
indexlist.append(dlist[i][1].index)
natomlist=[0]*len(Optimizer.atomlist)
for i in range(len(Optimizer.atomlist)):
atms1=[inds for inds in atmsr if inds.symbol==Optimizer.atomlist[i][0]]
natomlist[i]=(Optimizer.atomlist[i][0], len(atms1),Optimizer.atomlist[i][2],Optimizer.atomlist[i][3])
nsize = max(numpy.maximum.reduce(atmsr.get_positions())-numpy.minimum.reduce(atmsr.get_positions()))
repcenter = atmsr.get_center_of_mass()
atmsn = gen_pop_box(natomlist,nsize)
atmsn.translate(repcenter)
#Update individual with new atom positions
for i in range(len(indexlist)):
index=indexlist[i]
atms[index].position=atmsn[i].position
if Optimizer.structure=='Defect':
if Optimizer.isolate_mutation:
atms.extend(indb)
indiv[0]=atms.copy()
else:
natrep=0
pt=0
Optimizer.output.write('Random Group Replacement Mutation performed on individual\n')
Optimizer.output.write('Index = '+repr(indiv.index)+'\n')
Optimizer.output.write('Number of atoms replaced = '+repr(natrep)+'\n')
Optimizer.output.write('Geometry point = '+repr(pt)+'\n')
Optimizer.output.write(repr(indiv[0])+'\n')
muttype='RGR'+repr(natrep)
if indiv.energy==0:
indiv.history_index=indiv.history_index+'m'+muttype
else:
indiv.history_index=repr(indiv.index)+'m'+muttype
return indiv
from itertools import product
from scipy.signal import argrelmax
from workflow_analysis.analysis.plot import plot_pdf, colors
from pyiid.sim.dynamics import classical_dynamics
from pyiid.calc.calc_1d import Calc1D
from ase import Atoms
def null_func(atoms):
return np.zeros((len(atoms), 3))
atoms = Atoms(FaceCenteredCubic('Au', [[1, 0, 0], [1, 1, 0], [1, 1, 1]], (4, 6, 4)))
atoms.center()
s = ElasticScatter({'qmin': 3., 'rmax': 20.})
displacement = atoms.get_positions() - atoms.get_center_of_mass()
distance = np.sqrt(np.sum(displacement**2, axis=1))
print(np.max(distance))
norm_displacement = (displacement.T / distance).T
adp_tensor = norm_displacement * .01
print(np.max(adp_tensor))
adp_tensor_target = adp_tensor.copy()
target_atoms = atoms.copy()
target_adps = ADP(atoms, adps=adp_tensor_target)
target_atoms.info['adps'] = target_adps
target_pdf = s.get_pdf(target_atoms)
adp_calc = Calc1D(target_data=target_pdf,
from ase import Atoms, Atom
from ase.parallel import barrier, rank, size
from gpaw.cluster import Cluster
from gpaw.test import equal
from ase.structure import molecule
from math import pi, sqrt
R = 2.0
CO = Atoms([Atom('C', (1, 0, 0)), Atom('O', (1, 0, R))])
CO.rotate('y', pi/2)
equal(CO.positions[1, 0], R, 1e-10)
# translate
CO.translate(-CO.get_center_of_mass())
p = CO.positions.copy()
for i in range(2):
equal(p[i, 1], 0, 1e-10)
equal(p[i, 2], 0, 1e-10)
# rotate the nuclear axis to the direction (1,1,1)
CO.rotate(p[1] - p[0], (1, 1, 1))
q = CO.positions.copy()
for c in range(3):
equal(q[0, c], p[0, 0] / sqrt(3), 1e-10)
equal(q[1, c], p[1, 0] / sqrt(3), 1e-10)
# minimal box
b=4.0
CO = Cluster([Atom('C', (1, 0, 0)), Atom('O', (1, 0, R))])
from ase import Atoms, Atom
from ase.parallel import barrier, rank
from gpaw.cluster import Cluster
from gpaw.test import equal
from ase.build import molecule
from math import sqrt
R = 2.0
CO = Atoms([Atom('C', (1, 0, 0)), Atom('O', (1, 0, R))])
CO.rotate(90, 'y')
equal(CO.positions[1, 0], R, 1e-10)
# translate
CO.translate(-CO.get_center_of_mass())
p = CO.positions.copy()
for i in range(2):
equal(p[i, 1], 0, 1e-10)
equal(p[i, 2], 0, 1e-10)
# rotate the nuclear axis to the direction (1,1,1)
CO.rotate(p[1] - p[0], (1, 1, 1))
q = CO.positions.copy()
for c in range(3):
equal(q[0, c], p[0, 0] / sqrt(3), 1e-10)
equal(q[1, c], p[1, 0] / sqrt(3), 1e-10)
# minimal box
b = 4.0
CO = Cluster([Atom('C', (1, 0, 0)), Atom('O', (1, 0, R))])
"""Test that atoms.get_center_of_mass(scaled=True) works"""
import numpy as np
from ase import Atoms
d = 1.142
a = Atoms('CO', positions=[(2, 0, 0), (2, -d, 0)], pbc=True)
a.set_cell(np.array(((4, -4, 0), (0, 5.657, 0), (0, 0, 10))))
def array_almost_equal(a1, a2, tol=np.finfo(type(1.0)).eps):
return (np.abs(a1 - a2) < tol).all()
scaledref = np.array((0.5, 0.23823499, 0.))
assert array_almost_equal(a.get_center_of_mass(scaled=True), scaledref, tol=1e-8)
