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)