def main(argv): format = None zmat = None while argv[0].startswith("--"): if argv[0] == '--format': format = argv[1] argv = argv[2:] elif argv[0] == '--zmatrix': __, zmat, v_name, __, __, __,__ = read_zmt_from_file(argv[1]) argv = argv[2:] elif argv[0] == '--help': print __doc__ return geo1 = read(argv[0], format = format) geos = [read(arg, format = format) for arg in argv[1:]] if zmat == None: fun = Cartesian() else: fun = ZMat(zmat) symbols = geo1.get_chemical_symbols() assert len(geos) > 0 for geo in geos: assert geo.get_chemical_symbols() == symbols compare(geo1.get_positions(), geo.get_positions(), symbols, fun)
def check(self, filename='FORCE_CONSTANTS'): ref = io.read('SPOSCAR') files = shell_exec("ls dirs").split('\n') fc2 = readfc2(filename) np.set_printoptions(precision=2, suppress=True) vasprunxml = "dir_SPOSCAR/vasprun.xml" if exists(vasprunxml): vasprun = etree.iterparse(vasprunxml, tag='varray') forces0 = parseVasprun(vasprun, 'forces') print(forces0.max()) else: forces0 = 0.0 for file in files: print(file) POSCAR = 'dirs/%s/POSCAR' % file vasprunxml = "dirs/%s/vasprun.xml" % file atoms = io.read(POSCAR) u = atoms.positions - ref.positions f = -np.einsum('ijkl,jl', fc2, u) vasprun = etree.iterparse(vasprunxml, tag='varray') forces = parseVasprun(vasprun, 'forces') - forces0 print(np.abs(f).max(), "\n") print(np.abs(forces - f).max()) print(np.allclose(f, forces, atol=1e-2))
def main(argv=[]): kwargs = getArgs(argv) nam = kwargs['file'] fix = kwargs['layers'] pad = kwargs['pad'] v = kwargs['v'] format = kwargs['format'] if format: atoms = read(nam, format=format) elif "vasp" in nam or "POSCAR" in nam or "CONTCAR" in nam: atoms = read(nam, format="vasp") else: atoms = read(nam) if v: print "-file loaded." # TODO: ameliorate layerz = {round(a.z, 2): None for a in atoms} layerz_list = [None] + [z for z in sorted(layerz)] if v: print "layerz list:", layerz_list n_layers = len(layerz) atoms.set_tags([layerz_list.index(round(a.z, 2)) for a in atoms]) if v: print "-tags set." constraint = FixAtoms(mask=[a.tag <= fix for a in atoms]) atoms.set_constraint(constraint) if v: print "-constraints set." write('POSCAR' + pad, atoms, format='vasp', direct=True)
def dcdft(): os.environ['USER'] = '******' con = ase.db.connect('dcdft.json') with open('WIEN2k.txt') as fd: lines = fd.readlines() for line in lines[2:73]: words = line.split() symbol = words.pop(0) vol, B, Bp = (float(x) for x in words) filename = 'cif/' + symbol + '.cif' atoms = read(filename) M = {'Fe': 2.3, 'Co': 1.2, 'Ni': 0.6, 'Cr': 1.5, 'O': 1.5, 'Mn': 2.0}.get(symbol) if M is not None: magmoms = [M] * len(atoms) if symbol in ['Cr', 'O', 'Mn']: magmoms[len(atoms) // 2:] = [-M] * (len(atoms) // 2) atoms.set_initial_magnetic_moments(magmoms) con.write(atoms, name=symbol, w2k_B=B, w2k_Bp=Bp, w2k_volume=vol) filename = 'pcif/' + symbol + '.cif' p = read(filename, primitive_cell=True) v = atoms.get_volume() / len(atoms) dv = v - p.get_volume() / len(p) p2 = read(filename) dv2 = v - p2.get_volume() / len(p2) print(symbol, vol - atoms.get_volume() / len(atoms), len(atoms), len(p), dv, dv2) print(p.info)
def getjvq(): from np.linalg import norm unit = io.read("POSCAR_unit") atoms = io.read("POSCAR") supercell = map( int, norm( atoms.cell, axis=1) / norm( unit.cell, axis=1) + [.5] * 3) c = supercell q = [] u = [int(x / 2) * 2 + 1 for x in c] for i in range(u[0]): for j in range(u[1]): for k in range(u[2]): b = np.array([float(i - c[0] / 2) / c[0], float(j - c[1] / 2) / c[1], float(k - c[2] / 2) / c[2]]) q.append(b) allpos = np.load('allpos.npy') v = np.gradient(allpos)[0]
def _resume(self): """Attempt to resume a run, based on information in the log file. Note it will almost always be interrupted in the middle of either a qn or md run or when exceeding totalsteps, so it only has been tested in those cases currently.""" f = paropen(self._logfile, 'r') lines = f.read().splitlines() f.close() self._log('msg', 'Attempting to resume stopped run.') self._log('msg', 'Using existing minima file with %i prior ' 'minima: %s' % (len(self._minima), self._minima_traj)) mdcount, qncount = 0, 0 for line in lines: if (line[:4] == 'par:') and ('Ediff' not in line): self._temperature = eval(line.split()[1]) self._Ediff = eval(line.split()[2]) elif line[:18] == 'msg: Optimization:': qncount = int(line[19:].split('qn')[1]) elif line[:24] == 'msg: Molecular dynamics:': mdcount = int(line[25:].split('md')[1]) self._counter = max((mdcount, qncount)) if qncount == mdcount: # Either stopped during local optimization or terminated due to # max steps. self._log('msg', 'Attempting to resume at qn%05i' % qncount) if qncount > 0: atoms = io.read('qn%05i.traj' % (qncount - 1), index=-1) self._previous_optimum = atoms.copy() self._previous_energy = atoms.get_potential_energy() if os.path.getsize('qn%05i.traj' % qncount) > 0: atoms = io.read('qn%05i.traj' % qncount, index=-1) else: atoms = io.read('md%05i.traj' % qncount, index=-3) self._atoms.positions = atoms.get_positions() fmax = np.sqrt((atoms.get_forces() ** 2).sum(axis=1).max()) if fmax < self._fmax: # Stopped after a qn finished. self._log('msg', 'qn%05i fmax already less than fmax=%.3f' % (qncount, self._fmax)) self._counter += 1 return self._optimize() self._counter += 1 if qncount > 0: self._check_results() else: self._record_minimum() self._log('msg', 'Found a new minimum.') self._log('msg', 'Accepted new minimum.') self._log('par') elif qncount < mdcount: # Probably stopped during molecular dynamics. self._log('msg', 'Attempting to resume at md%05i.' % mdcount) atoms = io.read('qn%05i.traj' % qncount, index=-1) self._previous_optimum = atoms.copy() self._previous_energy = atoms.get_potential_energy() self._molecular_dynamics(resume=mdcount) self._optimize() self._counter += 1 self._check_results()
def main(argv=[]): args = getArgs(argv) atoms = read(args.file, format=args.format) if args.format else read(args.file) atoms = correct_z(atoms) atoms = fix_layers(atoms, args.fix, args.n_layers) kw = {'format': 'vasp', 'direct': True, 'vasp5': True, 'sort':True} write('POSCAR' + args.pad, atoms, **kw)
def main(argv=None): args = getArgs(argv) atoms = read(args.file, format=args.f) if args.f else struct = read(args.file) atoms = correct_z(atoms) kw = {"format": args.format} if args.format == 'vasp': kw['sort'] = True kw['vasp5'] = True kw['direct'] = True write(args.nam, atoms, **kw)
def getdispforce(self, files): force = "" disp = "" orig = io.read('POSCAR-supercell').positions for dir0 in files: forcearr = read_forces( 'dirs/dir_%s/vasprun.xml' % dir0) / 25.7110 # in Rd/bohr force += matrixFormat(forcearr) disparr = (io.read('dirs/dir_%s/POSCAR' % dir0).positions - orig ) * 1.889726 # in bohr disp += matrixFormat(disparr) tl.write(disp, "disp_all.dat") tl.write(force, "force_all.dat")
def getsatoms(self): filename = 'disp_fc3.yaml' if (tl.exists(filename)): return disp2atoms(filename) filename = 'disp.yaml' if (tl.exists(filename)): return disp2atoms(filename) filename = '3RD.SPOSCAR' if (tl.exists(filename)): from ase import io return io.read(filename, format='vasp') filename = 'SPOSCAR' if (tl.exists(filename)): from ase import io return io.read(filename, format='vasp')
def __cleanup__(self): """ Checks if any relaxations are done and load in the structure from the traj file. """ p = Popen(['ps -x -U `whoami`'], shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True) (_, fout) = (p.stdin, p.stdout) lines = fout.readlines() lines = [l for l in lines if l.find('defunct') == -1] stopped_runs = [] for i in range(len(self.running_pids) - 1, -1, -1): found = False for l in lines: if l.find(str(self.running_pids[i][1])) != -1: found = True break if not found: stopped_runs.append(self.running_pids.pop(i)) # All processes not running any more must be complete and should # be loaded in. for (confid, _) in stopped_runs: try: tf = self.tmp_folder a = read('{0}/cand{1}_done.traj'.format(tf, confid)) self.dc.add_relaxed_step(a) except IOError as e: print(e)
def vasp2xyz(): try: from lxml import etree except ImportError: print "You need to install python-lxml." print "start parse" xml = etree.parse("vasprun.xml") calculations = xml.xpath('//calculation') print 'len(calculations)=', len(calculations) from ase.io.trajectory import PickleTrajectory atoms = io.read('POSCAR') traj = PickleTrajectory('a.traj', 'w', atoms) print "start find forces and positions" allforce = [] allpos = [] def toarr(v): x = v.text.split() return map(float, x) for i, u in enumerate(calculations): print "step : ", i forces = map(toarr, u.xpath('./varray[@name="forces"]/v')) positions = map(toarr, u.xpath( './structure/varray[@name="positions"]/v')) atoms.set_scaled_positions(positions) allforce.append(forces) allpos.append(positions) traj.write() np.save('allforce.npy', allforce) np.save('allpos.npy', allpos) passthru("ase-gui a.traj -o a.xyz ")
def getcharge(): atoms = io.read("POSCAR") n = len(atoms) + 10 size = map(int, shell_exec("head -%s CHG|tail -1" % n).split()) ch = np.loadtxt("CHG", skiprows=n).reshape([size[2], size[1], size[0]]) ch = np.einsum('kji', ch) return ch
def _cleanup(self): for r in self.results: if r.ready() and r.successful(): fname = r.get() a = read(fname) self.dc.add_relaxed_step(a) self.results.remove(r)
def read_nwchem(filename): """Method to read geometry from an NWChem input file.""" f = filename if isinstance(filename, str): f = open(filename) lines = f.readlines() # Find geometry region of input file. stopline = 0 for index, line in enumerate(lines): if line.startswith('geometry'): startline = index + 1 stopline = -1 elif (line.startswith('end') and stopline == -1): stopline = index # Format and send to read_xyz. xyz_text = '%i\n' % (stopline - startline) xyz_text += ' geometry\n' for line in lines[startline:stopline]: xyz_text += line atoms = read(StringIO(xyz_text), format='xyz') atoms.set_cell((0., 0., 0.)) # no unit cell defined if type(filename) == str: f.close() return atoms
def test_symmetry_dense(self): for calc in [{(1, 1): LennardJonesQuadratic(1, 1, 3), (1, 2): LennardJonesQuadratic(1.5, 0.8, 2.4), (2, 2): LennardJonesQuadratic(0.5, 0.88, 2.64)}]: a = io.read('KA256_Min.xyz') a.center(vacuum=5.0) b = calculator.PairPotential(calc) H = b.calculate_hessian_matrix(a, "dense") self.assertArrayAlmostEqual(np.sum(np.abs(H-H.T)), 0, tol=0)
def atoms_from_dump(filename, elements=None, index=-1): atoms = io.read(filename, format='lammps', index=index) if elements: s = atoms.numbers symbols = [elements[i - 1] for i in s] atoms.set_chemical_symbols(symbols) return atoms
def read_nwchem_output(filename): """Method to read geometry from a nwchem output.""" f = filename if isinstance(filename, str): f = open(filename) lines = f.readlines() i = 0 while i < len(lines): if lines[i].find('XYZ format geometry') >= 0: natoms = int(lines[i + 2].split()[0]) string = '' for j in range(2, natoms + 4): xyzstring = lines[i + j] symbol = xyzstring.split()[0].strip() # replace bq ghost with X: MDTMP can we do better? if symbol.startswith('bq'): xyzstring = xyzstring.replace(symbol, 'X') string += xyzstring atoms = read(StringIO(string), format='xyz') i += natoms + 4 else: i += 1 if isinstance(filename, str): f.close() return atoms
def build(self, name): args = self.args if "." in name: atoms = read(name) elif self.build_function: atoms = self.build_function(name, self.args) elif self.args.crystal_structure: atoms = self.build_bulk(name) else: atoms = self.build_molecule(name) if args.magnetic_moment: magmoms = np.array([float(m) for m in args.magnetic_moment.split(",")]) atoms.set_initial_magnetic_moments(np.tile(magmoms, len(atoms) // len(magmoms))) if args.modify: exec args.modify in {"atoms": atoms} if args.repeat is not None: r = args.repeat.split(",") if len(r) == 1: r = 3 * r atoms = atoms.repeat([int(c) for c in r]) return atoms
def generate_target(self): """Generates the target STEM image from the parameters. The bulk of this code generates the target from an atoms object. """ # Load the target from a file if (self.path is not None and os.path.isfile(os.path.join(self.path, 'target.npy'))): with open(os.path.join(self.path, 'target.npy'), "rb") as npy: self.target = np.load(npy) return if self.psf is None: self.generate_psf() if not self.parameters['kwargs']['target'].endswith('.xyz'): self.target = self.read_target(self.parameters['kwargs']['target']) self.phantom = False else: atoms = read(self.parameters['kwargs']['target']) self.target = self.get_image(atoms) self.phantom = True # Try saving the target for future calculations if self.path is not None: np.save(os.path.join(self.path, 'target'), self.target) return
def fit(filename): configs = read(filename + '@:') volumes = [a.get_volume() for a in configs] energies = [a.get_potential_energy() for a in configs] eos = EquationOfState(volumes, energies) v0, e0, B = eos.fit() return (4 * v0)**(1 / 3.0)
def get_trajectory(fname): """ Extra error tolerance when loading traj files. """ fname = str(fname) try: t = read(fname) except IOError, e: print("get_trajectory error " + e)
def read_dimer(self, filename, w_image, fformat): """ Read the dimer file with a given file format and call create_fragments after that. """ try: self.dimer = read(filename, index=w_image, format=fformat) except: print("ERROR: The file {0} was not found or the format {1} not known!".format(filename, fformat))
def import_atoms(self, filename, cur_frame): if filename: filename = filename[0] old_a = self.get_atoms(cur_frame) imp_a = read(filename, -1) new_a = old_a + imp_a self.initialize([new_a], [filename])
def unit(self): write(self.poscar,"POSCAR_ORI") atoms=io.read("POSCAR_ORI") return atoms
def prepare(infname='POSCAR',dlt1max=0.01,dlt2max=0.06): #...original system orig_atoms = read(infname,format='vasp') #...get deformations fmats = get_deformations(dlt1max,dlt2max) #...deform original system and save to _prefix_##/POSCAR for i,fmat in enumerate(fmats): atoms = orig_atoms.copy() dname = _prefix +"{0:02d}".format(i) os.system('mkdir -p {}'.format(dname)) print(dname) cell0 = atoms.get_cell() emat = 0.5 *(np.dot(fmat.T,fmat) -np.identity(3)) +np.identity(3) cell = np.dot(emat,cell0) # cell = np.dot(cell0,fmat.T) atoms.set_cell(cell,scale_atoms=True) atoms.write(dname+'/POSCAR',format='vasp',vasp5=True,direct=True, sort=False) print('prepare done') print('') print('After performing VASP or pmd calculations in these directories, ' +'run the following command:') print(' $ python elasticity.py analyze str.ref') print('or') print(' $ python elasticity.py analyze strs.pmd') print('')
def get_potential_energy(in_file='input.traj'): """ Performs a ASE get_potential_energy() call with the ase-espresso calculator with the keywords defined inside the atoms object information. This can be a singlepoint calculation or a full relaxation depending on the keywords. """ # Read the input file from the current directory atoms = read(in_file) # Planewave basis set requires periodic boundary conditions atoms.set_pbc([1, 1, 1]) # Assign kpoints to be split across nodes if get_nnodes() > 1: if not sum(atoms.info['kpts']) == 1: atoms.info['parflags'] = '-npool {}'.format(get_nnodes()) # Setting up the calculator calc = espresso(**atoms.info) atoms.set_calculator(calc) # Perform the calculation and write trajectory from log. atoms.get_potential_energy() images = log_to_atoms(out_file='output.traj') # Save the calculator to the local disk for later use. try: calc.save_flev_output() except(RuntimeError): calc.save_output() return atoms_to_encode(images)
def traj(self): """Get a trajectory. This reads Atoms objects from vasprun.xml. By default returns all images. If index is an integer, return that image. Technically, this is just a list of atoms with a SinglePointCalculator attached to them. This is usually only relevant if you have done a relaxation. If the calculation is an NEB, the images are returned. """ from ase.calculators.singlepoint import SinglePointCalculator as SPC self.update() if self.neb: images, energies = self.get_neb() tatoms = [x.copy() for x in images] for i, x in enumerate(tatoms): x.set_calculator(SPC(x, energy=energies[i])) return tatoms LOA = [] for atoms in read(os.path.join(self.directory, 'vasprun.xml'), ':'): catoms = atoms.copy() catoms = catoms[self.resort] catoms.set_calculator(SPC(catoms, energy=atoms.get_potential_energy())) LOA += [catoms] return LOA
def __init__(self, args, prop_fig, YFname): if args.tem_iter == 'tem': raise ValueError('text format only with iter') self.atoms = aio.read(prop_fig.fatoms) self.fname = self.determine_fname(args, perso=YFname) self.dr, self.origin, self.lbound, self.ubound, self.Array, \ self.box, self.dim = self.read_txt(args, self.fname) if args.quantity != 'polarizability': self.mesh3D() self.mesh2D() self.xy_prof = self.xy_mesh[:, int(self.xy_mesh.shape[1] / 2)] self.xz_prof = self.xz_mesh[int(self.xz_mesh.shape[0] / 2), :] self.yx_prof = self.yx_mesh[:, int(self.yx_mesh.shape[1] / 2)] self.yz_prof = self.yz_mesh[int(self.yz_mesh.shape[0] / 2), :] self.zx_prof = self.zx_mesh[:, int(self.zx_mesh.shape[1] / 2)] self.zy_prof = self.zy_mesh[int(self.zy_mesh.shape[0] / 2), :] self.set_carac(args, prop_fig)
def butane_single_process(): try: start_point = read('test_files/x0.xyz') start_point.set_calculator(EMT()) end_point = read('test_files/xN.xyz') traj = Curve(start_point, end_point, 12, 1E+03) compute_trajectory(traj, 9, 1E+03, 0.003, 'Butane', {'processes': 1}) return True except: return False
def run_dftb3_test(test=None, tol=0.05): mio_database_folder = os.getenv('MIO') if mio_database_folder is None: raise RuntimeError( 'Please use environment variable MIO to specify path to mio Slater-Koster tables.' ) dftb3_database_folder = os.getenv('DFTB3') if dftb3_database_folder is None: raise RuntimeError( 'Please use environment variable DFTB3 to specify path to 3ob Slater-Koster tables.' ) dftb2_calc = Atomistica( [ native.TightBinding( database_folder=mio_database_folder, SolverLAPACK=dict(electronic_T=0.001), SCC=dict( dq_crit=1e-6, mixing=0.05, # 0.2 andersen_memory=15, # 3 maximum_iterations=100, log=True)), native.DirectCoulomb(), native.SlaterCharges(cutoff=10.0) ], avgn=1000) dftb2_XH_calc = Atomistica( [ native.TightBinding( database_folder=mio_database_folder, SolverLAPACK=dict(electronic_T=0.001), SCC=dict( dq_crit=1e-6, mixing=0.05, # 0.2 andersen_memory=15, # 3 maximum_iterations=100, log=True)), native.DirectCoulomb(), native.SlaterCharges(cutoff=10.0, damp_gamma=True, zeta=3.70) ], avgn=1000) dftb3_calc = Atomistica( [ native.TightBinding( database_folder=mio_database_folder, SolverLAPACK=dict(electronic_T=0.001), SCC=dict( dq_crit=1e-6, mixing=0.05, # 0.2 andersen_memory=15, # 3 maximum_iterations=100, log=True)), native.DirectCoulomb(), native.SlaterCharges(cutoff=10.0, dftb3=True, HubbardDerivatives=dict(H=-0.1857, O=-0.1575)) ], avgn=1000) dftb3_XH_calc = Atomistica( [ native.TightBinding( database_folder=mio_database_folder, SolverLAPACK=dict(electronic_T=0.001), SCC=dict( dq_crit=1e-6, mixing=0.05, # 0.2 andersen_memory=15, # 3 maximum_iterations=100, log=True)), native.DirectCoulomb(), native.SlaterCharges(cutoff=10.0, dftb3=True, damp_gamma=True, zeta=4.05, HubbardDerivatives=dict(H=-0.1857, O=-0.1575)) ], avgn=1000) dftb3_XH_3ob_calc = Atomistica( [ native.TightBinding( database_folder=dftb3_database_folder, SolverLAPACK=dict(electronic_T=0.001), SCC=dict( dq_crit=1e-6, mixing=0.05, # 0.2 andersen_memory=15, # 3 maximum_iterations=100, log=True)), native.DirectCoulomb(), native.SlaterCharges(cutoff=10.0, dftb3=True, damp_gamma=True, zeta=4.00, HubbardDerivatives=dict(H=-0.1857, O=-0.1575)) ], avgn=1000) if test is None: print( ' nH2O| G3B3| DFTB2 (MIO) | DFTB2+XH (MIO) | DFTB3 (MIO) | DFTB3+XH (MIO) | DFTB3+XH (3OB) |' ) print( ' | | me ref. | me ref. | me ref. | me ref. | me ref. |' ) print( ' | |-----------------|-----------------|-----------------|-----------------|-----------------|' ) for name, data in table5_data.items(): e0_DFTB2 = 0.0 e0_DFTB3 = 0.0 e0_DFTB2_XH = 0.0 e0_DFTB3_XH = 0.0 e0_DFTB3_3ob_XH = 0.0 for structure in data['reference_structures']: if os.path.exists(structure): a = read(structure) else: a = molecule(structure) a.center(vacuum=10.0) a.set_calculator(dftb2_calc) FIRE(a, logfile=None).run(fmax=0.001) e0_DFTB2 += a.get_potential_energy() a.set_calculator(dftb2_XH_calc) FIRE(a, logfile=None).run(fmax=0.001) e0_DFTB2_XH += a.get_potential_energy() a.set_calculator(dftb3_calc) FIRE(a, logfile=None).run(fmax=0.001) e0_DFTB3 += a.get_potential_energy() a.set_calculator(dftb3_XH_calc) FIRE(a, logfile=None).run(fmax=0.001) e0_DFTB3_XH += a.get_potential_energy() a.set_calculator(dftb3_XH_3ob_calc) FIRE(a, logfile=None).run(fmax=0.001) e0_DFTB3_3ob_XH += a.get_potential_energy() eref_G3B3 = data['G3B3'] eref_DFTB2 = data['DFTB2'] eref_DFTB2_XH = data['DFTB2+XH'] eref_DFTB3 = data['DFTB3'] eref_DFTB3_XH = data['DFTB3+XH'] eref_DFTB3_3ob_XH = data['DFTB3+XH_3ob'] a = read(data['structure']) a.center(vacuum=10.0) a.set_calculator(dftb2_calc) FIRE(a, logfile=None).run(fmax=0.001) e_DFTB2 = a.get_potential_energy() e_DFTB2 = (e_DFTB2 - e0_DFTB2) / (ase.units.kcal / ase.units.mol) a.set_calculator(dftb2_XH_calc) FIRE(a, logfile=None).run(fmax=0.001) e_DFTB2_XH = a.get_potential_energy() e_DFTB2_XH = (e_DFTB2_XH - e0_DFTB2_XH) / (ase.units.kcal / ase.units.mol) a.set_calculator(dftb3_calc) FIRE(a, logfile=None).run(fmax=0.001) e_DFTB3 = a.get_potential_energy() e_DFTB3 = (e_DFTB3 - e0_DFTB3) / (ase.units.kcal / ase.units.mol) a.set_calculator(dftb3_XH_calc) FIRE(a, logfile=None).run(fmax=0.001) e_DFTB3_XH = a.get_potential_energy() e_DFTB3_XH = (e_DFTB3_XH - e0_DFTB3_XH) / (ase.units.kcal / ase.units.mol) a.set_calculator(dftb3_XH_3ob_calc) FIRE(a, logfile=None).run(fmax=0.001) e_DFTB3_3ob_XH = a.get_potential_energy() e_DFTB3_3ob_XH = (e_DFTB3_3ob_XH - e0_DFTB3_3ob_XH) / (ase.units.kcal / ase.units.mol) success_DFTB2 = abs(e_DFTB2 - eref_G3B3 - eref_DFTB2) < tol success_DFTB2_XH = abs(e_DFTB2_XH - eref_G3B3 - eref_DFTB2_XH) < tol success_DFTB3 = abs(e_DFTB3 - eref_G3B3 - eref_DFTB3) < tol success_DFTB3_XH = abs(e_DFTB3_XH - eref_G3B3 - eref_DFTB3_XH) < tol success_DFTB3_3ob_XH = abs(e_DFTB3_3ob_XH - eref_G3B3 - eref_DFTB3_3ob_XH) < tol success_str = {True: ' ', False: 'X'} if test is None: print( '{0:>8}| {1:>7.3f}|{2:>7.3f} {3:>7.3f} {4}|{5:>7.3f} {6:>7.3f} {7}|{8:>7.3f} {9:>7.3f} {10}|{11:>7.3f} {12:>7.3f} {13}|{14:>7.3f} {15:>7.3f} {16}|' .format(name, eref_G3B3, e_DFTB2 - eref_G3B3, eref_DFTB2, success_str[success_DFTB2], e_DFTB2_XH - eref_G3B3, eref_DFTB2_XH, success_str[success_DFTB2_XH], e_DFTB3 - eref_G3B3, eref_DFTB3, success_str[success_DFTB3], e_DFTB3_XH - eref_G3B3, eref_DFTB3_XH, success_str[success_DFTB3_XH], e_DFTB3_3ob_XH - eref_G3B3, eref_DFTB3_3ob_XH, success_str[success_DFTB3_3ob_XH])) else: test.assertTrue(success_DFTB2) test.assertTrue(success_DFTB2_XH) test.assertTrue(success_DFTB3) test.assertTrue(success_DFTB3_XH) test.assertTrue(success_DFTB3_3ob_XH)
os.remove('4.nc') # Add 'id' field and check if it is read correctly co.set_array('id', np.array([2, 1])) traj = NetCDFTrajectory('5.nc', 'w', co) traj.write(co, arrays=['id']) traj.close() traj = NetCDFTrajectory('5.nc', 'r') # assert np.all(traj[0].numbers == [8, 6]) assert np.all( np.abs(traj[0].positions - np.array([[2, 2, 3.7], [2., 2., 2.5]])) < 1e-6) traj.close() a = read('5.nc') assert (len(a) == 2) os.remove('5.nc') # Create a NetCDF file with a per-file definition of atomic numbers. ASE # NetCDFTrajectory can read but not write these types of files. import netCDF4 nc = netCDF4.Dataset('6.nc', 'w') nc.createDimension('frame', None) nc.createDimension('atom', 2) nc.createDimension('spatial', 3) nc.createDimension('cell_spatial', 3) nc.createDimension('cell_angular', 3) nc.createVariable('atom_types', 'i', ('atom', ))
"""Read and write json from/to file descriptor.""" import sys from io import StringIO, BytesIO from ase.io import read, write s = u""" {"1": {"numbers": [1, 1], "positions": [[0.0, 0.0, 0.35], [0.0, 0.0, -0.35]]}} """ fd = StringIO(s) a = read(fd, format='json') assert a.get_chemical_formula() == 'H2' if sys.version_info[0] == 2: fd = BytesIO() else: fd = StringIO() write(fd, a, format='json') fd.seek(0) a = read(fd, format='json') assert a.get_chemical_formula() == 'H2'
f.close() print(folder, erg) return erg prefix = "sset" property_name = "energy" sset = StructuresSet(db_fname=prefix+".json") sset.read_property_values(property_name, write_to_file=False, read_property=read_property) sset.serialize(prefix+".json") refs = StructuresSet(db_fname="refs.json") refs.read_property_values(property_name, write_to_file=False, read_property=read_property) refs.serialize("refs.json") ref_en = refs.get_property_values(property_name) plot_property_vs_concentration(sset, site_type=0, property_name=property_name,refs=ref_en,scale=0.6) # See the most stable structure from ase.visualize import view import numpy as np array = sset.get_property_values(property_name) lowest_energy_structure_index = np.where(array == np.amin(array))[0][0] # GET STRUCTURES/ GET STRUCTURE IS NOT SHOWING THE CORRECT STRUCTURE #lowest_energy_structure = sset.get_structures()[lowest_energy_structure_index] # not working for the moment os.chdir(sset.get_folders()[lowest_energy_structure_index]) lowest_energy_structure = read("geometry.json") view(lowest_energy_structure)
def main(): print('Welcome.') #global variables global superCell global trajFileIn global trajFileOut #get Input from stdin if len(sys.argv) is 1: trajFileIn, trajFileOut, superCell = getSTDInput() #if we have the right amount of arguments elif len(sys.argv) is 6: print('Provided information as arguments.') trajFileIn, trajFileOut, superCell = getArgumentsInput(sys.argv) #otherwise something is wrong else: print('You gave some arguments, but the number of them is wrong. Please provide "<InputFile> <OutFile> <n1> <n2> <n3>"') sys.exit(1) #check input checkInput(trajFileIn, superCell) #open files inMol = io.read(trajFileIn,index=slice(0,None)) #if output exists mv to .bak if os.path.isfile(trajFileOut): print('ATTENTION: Output file exists, moving to *.bak') os.rename(trajFileOut, trajFileOut+'.bak') #open output for writing outFile = open(trajFileOut, 'w') #convert input superCell to integer tuple try: superCell = tuple([int(x) for x in superCell]) except: print('ERROR: SuperCell Vector contains non-integer values!') sys.exit(1) #check input superCell vector if any(x for x in superCell) < 1: print('ERROR: SuperCell Tuple contains values smaller than 1!') sys.exit(1) #calculate number of unit cells superCellSize = np.prod(np.array(superCell), dtype='int') print('You will end up with '+str(superCellSize)+' unit cells in each frame.') #iterate over frames nFrames = len(inMol) i = 0 print('Adding Coordinates:') for frame in inMol: i += 1 progress(i/nFrames) frame *= superCell print('Writing to file:') i = 0 for frame in inMol: i += 1 progress(i/nFrames) io.extxyz.write_xyz(outFile,frame) outFile.close()
import os from ase import Atoms from ase.io import read, write from ase.calculators.exciting import Exciting from ase.units import Bohr, Hartree a = Atoms('N3O', [(0, 0, 0), (1, 0, 0), (0, 0, 1), (0.5, 0.5, 0.5)], pbc=True) write('geo.exi', a) b = read('geo.exi') print a print a.get_positions() print b print b.get_positions() calculator = Exciting( dir='excitingtestfiles', kpts=(4, 4, 3), maxscl=3, #bin='/fshome/chm/git/exciting/bin/excitingser' )
def parse_info(path_i): """ """ #| - parse_info from ase import io files_i = os.listdir(path_i) if "init_graphene.cif" in files_i: atoms_init_graph_i = io.read( os.path.join( path_i, "init_graphene.cif", ) ) else: atoms_init_graph_i = None if "init_support.cif" in files_i: atoms_init_supp_i = io.read( os.path.join( path_i, "init_support.cif", ) ) else: atoms_init_supp_i = None structures_found = os.path.isdir( os.path.join( path_i, "01_heterostructures", ) ) if structures_found: out_atoms_path_list = os.listdir(os.path.join( path_i, "01_heterostructures", )) out_atoms_list = [] for out_i in out_atoms_path_list: out_atoms_i = io.read( os.path.join( path_i, "01_heterostructures", out_i, ) ) out_atoms_list.append(out_atoms_i) else: out_atoms_list = None out_dict = { # "": , "init_graph_atoms": atoms_init_graph_i, "init_support_atoms": atoms_init_supp_i, "out_atoms": out_atoms_list, } return(out_dict)
from ase import io from espresso.vibespresso import vibespresso from ase.vibrations import Vibrations from ase.thermochemistry import HarmonicThermo ################## # Inputs ######### ################## vib_atoms = [1, 7] # List of atoms allowed to vibrate #Convergence ################## # Slab ########### ################## atoms = io.read('qn.traj') # optimized atoms.set_masses() calc = vibespresso( pw=800, # planewave cutoff dw=8000, # density cutoff nbands=-10, # number of bands kpts=(8, 8, 8), # k points xc='beef', # exchange correlation method sigma=0.2, # Fermi temperature dipole={'status': False}, spinpol=False, convergence={ 'energy': 0.0005, 'mixing': 0.1,
def convert_fil(namefile): from ase.io import read from ase.io import write slab=read(namefile) write('x.xyz', slab)
butadiene = u"""10 C 3.649801161546418 5.442281389577507 3.863313703750026 C 5.051651240044169 5.368220758269772 4.162165876906096 C 5.750174626862403 4.162261915959347 4.240449977068684 C 7.150130182125531 4.155384186721486 4.537328602062397 H 3.218154657585170 4.565210696328925 3.522601038049320 H 3.077656122062729 6.375092902842770 3.826039498180272 H 5.478464901706067 6.370680001794822 4.422235395756437 H 5.320549047980879 3.220584852467720 3.974551561510350 H 7.723359150977955 3.224855971783890 4.574146712279462 H 7.580803493981530 5.034479218283977 4.877211530909463 """ h = 0.3 atoms = Cluster(read(io.StringIO(butadiene), format='xyz')) atoms.minimal_box(3.0, h) atoms.set_calculator(GPAW(h=h)) if 0: dyn = FIRE(atoms) dyn.run(fmax=0.05) atoms.write('butadiene.xyz') vibname = 'fcvib' vib = Vibrations(atoms, name=vibname) vib.run() # Modul a = FranckCondon(atoms, vibname, minfreq=250) # excited state forces
dumpconf() elif args['calc']: if confname: loadconf(confname) #...output for checking print(' block:') for i in range(3): print(' {0:8.2f} {1:8.2f} {2:8.2f}'.format(block[i, 0], block[i, 1], block[i, 2])) print(' nei_perf:') for i in range(len(nei_perf)): print(' {0:4d}:'.format(i) + ' {0:8.2f} {1:8.2f} {2:8.2f}'.format( nei_perf[i, 0], nei_perf[i, 1], nei_perf[i, 2])) atoms = read(fname, format='lammps-dump') nye_tensor(atoms) elif args['plot']: #...See http://matplotlib.org/examples/pylab_examples/griddata_demo.html #...for contour plot example. from matplotlib.mlab import griddata import matplotlib.pyplot as plt if confname: loadconf(confname) comp = args['--component'] xo = float(args['-x']) yo = float(args['-y']) w = int(args['--width']) h = int(args['--height']) if len(comp) != 2:
from ase.io import read, write from ase.visualize import view from blase.tools import write_blender, get_polyhedra_kinds, get_bondpairs import numpy as np from pprint import pprint from ase.data import covalent_radii atoms = read('datas/perovskite.xyz') atoms.pbc = [True, True, True] atoms = atoms*[2, 2, 2] # atoms.write('datas/perovskite-2-2-2.in') print(atoms) kind_props = { 'Pb': {'radius': 1.0, 'color': [100/255.0, 191/255.0, 56/255.0]}, 'O': {'radius': 1.0, } } # bond_list = get_bondpairs(atoms, rmbonds = [['Ti', 'Ti']]) kwargs = {'show_unit_cell': 1, 'engine': 'BLENDER_WORKBENCH', #'BLENDER_EEVEE' #'BLENDER_WORKBENCH', CYCLES 'radii': 0.6, 'bond_cutoff': 1.0, # 'bond_list': bond_list, 'kind_props': kind_props, 'display': True, # 'polyhedra_dict': {'Pb': ['I']}, # 'search_pbc_atoms': {'bonds_dict':{'I': [['Pb'], -1]}, 'molecule_list':[['C', 'N']]}, 'run_render': False, 'outfile': 'figs/test-polyhedra',
def plot_conf(ax, atoms, rot=False): colors = np.array([jmol_colors[atom.number] for atom in atoms]) alp = [None] * colors.shape[0] for i, a in enumerate(atoms): if a.symbol == 'Ti' or a.symbol == 'O': if a.position[2] < 11.95: alp[i] = 0.3 if rot: atoms.rotate('x', pi / 2) plot_atoms(ax, atoms, [0, 2, 1], colors, alp, z=-1) data = read('V2O5_TiO2_101_DFTlowlyingsorted.traj@:') image = data[16] * (2, 2, 1) #image = read('anataseTi24O48_101surface_optPBEesben.traj') * (2,2,1) write('221image.traj', image) # Make array of indices for atoms that should be repeated in x and y directions plt.figure(figsize=(6.0, 10.0)) gs = gridspec.GridSpec(2, 1, height_ratios=[7.0, 9.5]) cell = image.get_cell() #image.translate(-cell[:,0]/3.) #image.translate(-cell[:,1]/3.) #view(image) # 0 0 ax = plt.subplot(gs[0, 0])
def finish_relaxation(self, structure, fixed_frame, parameters, directory): """ Finishes unfinished calculation Reads the output in logfile and compares to the convergence criteria in parameters.json file. If no "finished" reads the trajectory file and relax the structure. Arguments: structure {[type]} -- [description] fixed_frame {[type]} -- [description] parameters {[type]} -- [description] directory {[type]} -- [description] """ def find_traj(directory): for output in os.listdir(directory): if "trajectory" in output and ".traj" in output and "history" not in output: return output else: return None def send_traj_to_history(name, directory): traj = os.path.join(directory, "trajectory_{}.traj".format(name)) history_trajs = [ i for i in os.listdir(directory) if "history" in i ] name_history_traj = "{:05d}_history_trajectory_{}.traj".format( len(history_trajs) + 1, name) shutil.copyfile(traj, os.path.join(directory, name_history_traj)) def concatenate_trajs(name, directory): traj = "trajectory_{}.traj".format(name) trajs = [i for i in os.listdir(directory) if "history" in i] history_trajs = " ".join(sorted(trajs)) temp_traj = "temp.traj" os.system("cd {} && ase gui {} {} -o {}".format( directory, history_trajs, traj, temp_traj)) os.rename(os.path.join(directory, temp_traj), os.path.join(directory, traj)) # Cleaning up for i in trajs: os.remove(os.path.join(directory, i)) def finished(directory): f = open(os.path.join(directory, "finished"), "w") f.write("Calculation was finished") f.close() def perform_from_last(directory, traj): if traj == None: return False else: size = os.path.getsize(os.path.join(directory, traj)) if size == 0: history_trajs = [ i for i in os.listdir(directory) if "history" in i ] if len(history_trajs) > 0: name_history_traj = "{:05d}_history_{}".format( len(history_trajs), traj) os.rename(os.path.join(directory, name_history_traj), os.path.join(directory, traj)) return True else: return False else: return True if os.path.basename(os.path.normpath(directory)) != format(0, "010d"): if not "finished" in os.listdir( directory) and not "known" in os.listdir(directory): traj = find_traj(directory) if perform_from_last(directory, traj): if len(structure.molecules) > 1: molsize = len(structure.molecules[0]) * len( structure.molecules) else: molsize = len(structure.molecules[0]) if parameters["calculator"]["preconditioner"][ "rmsd_update"]["activate"]: rmsd_threshhold = parameters["calculator"][ "preconditioner"]["rmsd_update"]["value"] else: rmsd_threshhold = 100000000000 name = parameters["name"] # Save the history of trajectory send_traj_to_history(name, directory) # Perform relaxation traj = os.path.join(directory, "trajectory_{}.traj".format(name)) t = Trajectory(os.path.join(directory, traj)) atoms = t[-1].copy() self.set_constrains(atoms, parameters) atoms.set_calculator(self.calculator) H0 = np.eye(3 * len(atoms)) * 70 opt = BFGS_mod(atoms, trajectory=traj, initial=atoms[:molsize], molindixes=list(range(molsize)), rmsd_dev=rmsd_threshhold, structure=structure, fixed_frame=fixed_frame, parameters=parameters, H0=H0, logfile=os.path.join( directory, "logfile.log"), restart=os.path.join(directory, 'qn.pckl')) fmax = parameters["calculator"]["fmax"] opt.run(fmax=fmax, steps=1000) concatenate_trajs(name, directory) try: calculator.close() except: pass finished(directory) else: # Didn't perform any step - start relaxation #from initial .in geometry. foldername = os.path.basename(os.path.normpath(directory)) structure_file = os.path.join(directory, foldername + ".in") for i in os.listdir(directory): if os.path.join(directory, i) != structure_file: os.remove(os.path.join(directory, i)) atoms = read(os.path.join(directory, foldername + ".in"), format="aims") if len(structure.molecules) > 1: molsize = len(structure.molecules[0]) * len( structure.molecules) else: molsize = len(structure.molecules[0]) name = parameters["name"] self.set_constrains(atoms, parameters) atoms.set_calculator(self.calculator) traj = os.path.join(directory, "trajectory_{}.traj".format(name)) if parameters["calculator"]["preconditioner"][ "rmsd_update"]["activate"]: rmsd_threshhold = parameters["calculator"][ "preconditioner"]["rmsd_update"]["value"] else: rmsd_threshhold = 100000000000 H0 = np.eye(3 * len(atoms)) * 70 opt = BFGS_mod(atoms, trajectory=traj, initial=atoms[:molsize], molindixes=list(range(molsize)), rmsd_dev=rmsd_threshhold, structure=structure, fixed_frame=fixed_frame, parameters=parameters, H0=H0, logfile=os.path.join( directory, "logfile.log"), restart=os.path.join(directory, 'qn.pckl')) if not hasattr(structure, "mu"): structure.mu = 1 if not hasattr(structure, "A"): structure.A = 1 opt.H0 = precon.preconditioned_hessian(structure, fixed_frame, parameters, atoms, H0, task="initial") np.savetxt( os.path.join(directory, "hes_{}.hes".format(name)), opt.H0) fmax = parameters["calculator"]["fmax"] opt.run(fmax=fmax, steps=1000) try: calculator.close() except: pass finished(directory)
# if (atom.number ==8 and i >= 135+colorlenth*5 and i <colorlenth*6 ): # colors[i] =[102/255, 0/255, 0/255] alp = [None] * colors.shape[0] for i,a in enumerate(atoms): if a.symbol == 'Al' or a.symbol == 'O': if a.position[2] < 9.7: alp[i] = 0.3 if rot: atoms.rotate('x',pi/2) plot_atoms(ax, atoms, [0,2,1], colors, alp, z=-1) data=read(sys.argv[1]+'@:') energydif =np.zeros(len(data)) for j in range(len(data)): GM_energy = data[0].get_potential_energy() energydif[j] = (data[j].get_potential_energy() - GM_energy) #print('{:3.3f}'.format(energydif[j])) for j in range(7,len(data)): atoms = data[j] colorlenth = len(atoms) atoms =atoms*(3,3,1) print(colorlenth) # write('newimage.traj',atoms) #exit() a=atoms del atoms[[atom.index for atom in atoms if atom.index <=colorlenth*5-14 or atom.index >=colorlenth*5]] #view(atoms)
import numpy as np from ase import io, atoms Temp = '300' atoms = io.read('POSCAR') pos = atoms.get_positions() disp = np.loadtxt('thermal_displacements.yaml', skiprows=6, usecols=(2, 3, 4)) pos += disp atoms.set_positions(pos) io.write('POSCAR' + Temp, atoms, direct=True)
def read_atoms(self, filename): """Read the atoms from file located in the VASP working directory. Normally called CONTCAR.""" return read(filename)[self.resort]
def test_read_write_roundtrip(atoms, vasp5, filename): write(filename, atoms, vasp5=vasp5) atoms_loaded = read(filename) assert len(compare_atoms(atoms, atoms_loaded)) == 0
with pushd("image_{}".format(image_num)) as ctx1: shutil.copy("../ctrl.dat", "./ctrl.dat") atoms_to_site(atoms) if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument("-i", "--input", help="input format suffix", default="xyz") parser.add_argument("-o", "--output", help="output format suffix", default="site") parser.add_argument("-s", "--struct_file", help="input file name", required=True) args = parser.parse_args() print args.input, args.output if (args.input == "xyz" and args.output == "site"): ats = io.read(args.struct_file) atoms_to_site(ats) elif (args.input == "pos" and args.output == "xyz"): pos_to_xyz(args.struct_file) else: print "No conversion method available"
from os.path import basename from os import system from run_testRun import run_testRun from set_calc import set_bader_calc testRun = False file_name_py = basename(__file__) file_name = file_name_py.replace('.py', '') file_traj = file_name + '.traj' start_file = '../In2O3_110_H-1.traj' mode = 'a' try: sys = Trajectory(file_traj, 'r')[-1] except (IOError, RuntimeError): print "Importing trajectory file from: %s" % start_file sys = read(start_file) mode = 'w' else: print "Importing trajectory file from: %s" % file_traj set_bader_calc(sys, sigma=0.05) print "Constraints:" print " c: Fix bottom two layers." c = FixAtoms(mask=[atom.z < 8 for atom in sys]) sys.set_constraint(c) if testRun == True: run_testRun(sys) else: geo_traj = Trajectory(file_traj, mode, sys) dyn = LBFGS(sys, trajectory=geo_traj) dyn.run(fmax=0.05)
# 2.C Optimize using LBFGS. initial_lbfgs = atoms.copy() initial_lbfgs.set_calculator(calc) lbfgs_opt = LBFGS(initial_lbfgs, trajectory='results_lbfgs.traj') lbfgs_opt.run(fmax=0.01) # 2.D Optimize using FIRE. initial_fire = atoms.copy() initial_fire.set_calculator(calc) fire_opt = FIRE(initial_fire, trajectory='results_fire.traj') fire_opt.run(fmax=0.01) # 3. Summary of the results: ############################################################################### print('\n Summary of the results:\n ------------------------------------') fire_results = read('results_fire.traj', ':') print('Number of function evaluations using FIRE:', len(fire_results)) lbfgs_results = read('results_lbfgs.traj', ':') print('Number of function evaluations using LBFGS:', len(lbfgs_results)) gpmin_results = read('results_gpmin.traj', ':') print('Number of function evaluations using GPMin:', gpmin_opt.function_calls) catlearn_results = read('results_catlearn.traj', ':') print('Number of function evaluations using MLMin (CatLearn):', len(catlearn_results))
from ase.vibrations import Vibrations from ase.thermochemistry import HarmonicThermo # My Modules from ase_modules.ase_methods import clean_up_dft, an_ads_vib #__| # | - Script Inputs dipole_corr = False indices_list = [3] name = "vib_vasp" #__| # | - Read Atoms Object if os.path.isfile("init.cif"): atoms = io.read('init.cif') elif os.path.isfile("init.traj"): atoms = io.read('init.traj') #__| # | - Copy Previous OUTCAR and moments.traj subprocess.call('cp -rf OUTCAR OUTCAR_$(date +%s)', shell=True) subprocess.call('cp -rf moments.traj moments.traj_$(date +%s)', shell=True) #__| # | - Calculator calc = vasp_calculator.Vasp( lwave=False, encut=500, xc='PBE', #setups={'O': '_s', 'C': '_s'},
# second atom first atom print('PBE energy minimum:') print('hydrogen molecule energy: %7.3f eV' % e2) print('bondlength : %7.3f Ang' % d0) molecule = GPAW('H2fa.gpw', txt='H2.txt').get_atoms() relax = BFGS(molecule) relax.run(fmax=0.05) e2q = molecule.get_potential_energy() niter2q = calc.get_number_of_iterations() positions = molecule.get_positions() d0q = positions[1, 0] - positions[0, 0] assert abs(e2 - e2q) < 2e-6 assert abs(d0q - d0) < 4e-4 f0 = molecule.get_forces() del relax, molecule from gpaw.mpi import world world.barrier() # syncronize before reading text output file f = read('H2.txt').get_forces() assert abs(f - f0).max() < 5e-6 # 5 digits in txt file energy_tolerance = 0.00005 niter_tolerance = 0 equal(e1, -6.287873, energy_tolerance) equal(e2, -6.290744, energy_tolerance) equal(e2q, -6.290744, energy_tolerance)
from __future__ import print_function from ase.dft.kpoints import bandpath from ase.io import read from ase.parallel import paropen from gpaw import GPAW a = read('gs_Bi2Se3.gpw') G = [0.0, 0.0, 0.0] L = [0.5, 0.0, 0.0] F = [0.5, 0.5, 0.0] Z = [0.5, 0.5, 0.5] kpts, x, X = bandpath([G, Z, F, G, L], a.cell, npoints=200) calc = GPAW('gs_Bi2Se3.gpw', kpts=kpts, symmetry='off', fixdensity=True, txt='Bi2Se3_bands.txt') calc.get_potential_energy() calc.write('Bi2Se3_bands.gpw') with paropen('kpath.dat', 'w') as f: for k in x: print(k, file=f) with paropen('highsym.dat', 'w') as f: for k in X: print(k, file=f)
# If the structure is already fully relaxed just return it traj = Trajectory(label + '_lcao.traj', 'w', structure) while (structure.get_forces()** 2).sum(axis=1).max()**0.5 > forcemax and niter < niter_max: dyn = BFGS(structure, logfile=label + '.log') vb = VariansBreak(structure, dyn, min_stdev=0.01, N=15) dyn.attach(traj) dyn.attach(vb) dyn.run(fmax=forcemax, steps=steps) niter += 1 #print('relaxgpaw over',flush=True) return structure calc = GPAW(mode=PW(500), xc='PBE', setups={'Ti': ':d,3.5'}, basis='dzp', kpts=(2, 2, 1)) traj = Trajectory('V2O5_2H2O_Ovcy_TiO2_101surface_DFTrelaxed.traj', 'w') name = 'V2O5_2H2O_Ovcy_TiO2_101surface_gm' data = read('V2O5_2H2O_Ovcy_TiO2_101_newstrufound.traj@:') for i in range(1, len(data)): name = 'V2O5_2H2O_Ovcy_TiO2_101surface_isomer_{}'.format(i) a = data[i] a.set_calculator(calc) a_relaxed = relaxGPAW(a, name, forcemax=0.02, niter_max=3, steps=100) traj.write(a_relaxed)
''' cutoff = 17 'Load infomration from data dictionary (local)' try: with open("dir_data.json", "r") as read_file: data = json.load(read_file) qm = data['qm_region'] except: print('dir_data.json is not available') exit() 'load qm structure' try: atoms = io.read('input.xyz') except: print('input.xyz is not available') exit() 'generate list of atoms outside cutoff' to_be_deleted = [] for atom in atoms: for qm_atom in qm: d = atoms.get_distance(atom.index, qm_atom) if d > cutoff: if atom.index not in to_be_deleted: if atom.index not in data['qm_region']: to_be_deleted.append(atom.index) to_be_deleted.reverse() #so we don't mess up the numbering
def get_infrared_intensities(self): """Calculate infrared intensities of vibrational modes. Returns an array of normalized intensities for each vibrational mode. You should have run the vibrational calculation already. This function does not run it for you. python translation of # A utility for calculating the vibrational intensities from VASP output (OUTCAR) # (C) David Karhanek, 2011-03-25, ICIQ Tarragona, Spain (www.iciq.es) http://homepage.univie.ac.at/david.karhanek/downloads.html#Entry02 """ assert self.parameters.get('lepsilon', None) is True assert self.parameters.get('nwrite', 0) == 3 assert self.parameters.get('ibrion', 0) == 7 self.update() atoms = read(os.path.join(self.directory, 'POSCAR'), format='vasp') NIONS = len(atoms) BORN_NROWS = NIONS * 4 + 1 with open(os.path.join(self.directory, 'OUTCAR'), 'r') as f: alltext = f.read() f.seek(0) alllines = f.readlines() f.close() if 'BORN' not in alltext: raise Exception('Born effective charges missing. ' 'Did you use IBRION=7 or 8?') if 'Eigenvectors after division by SQRT(mass)' not in alltext: raise Exception('You must rerun with NWRITE=3 to get ' 'sqrt(mass) weighted eigenvectors') # get the Born charges for i, line in enumerate(alllines): if 'BORN EFFECTIVE CHARGES' in line: break BORN_MATRICES = [] i += 2 # skip a line for j in range(NIONS): BM = [] i += 1 # skips the ion count line for k in range(3): line = alllines[i] fields = line.split() BM.append([float(x) for x in fields[1:4]]) i += 1 # advance a line BORN_MATRICES.append(BM) BORN_MATRICES = np.array(BORN_MATRICES) # Get the eigenvectors and eigenvalues. maybe I can replace this # code with my other code. for now I just reproduce the count # number of vibs. this gets the number from outcar. it seems like # it should be known in advance unless constraints make it hard to # tell. # the next code in the shell script just copies code to eigenvectors.txt for i, line in enumerate(alllines): if 'Eigenvectors after division by SQRT(mass)' in line: break EIG_NVIBS = 0 for line in alllines[i:]: if ('f' in line and 'THz' in line and 'cm-1' in line): EIG_NVIBS += 1 EIG_NIONS = BORN_NROWS # I guess this counts blank rows and non-data rows # EIG_NROWS = (EIG_NIONS + 3) * EIG_NVIBS + 3 # i is where the data starts i += 6 EIGENVALUES = [] EIGENVECTORS = [] for j in range(EIG_NVIBS): mode = [] EIGENVALUES.append(alllines[i]) # frequencies are here i += 1 # skip the frequency line i += 1 # skip the xyz line for k in range(3): fields = [float(x) for x in alllines[i].split()] mode.append(fields[3:]) i += 1 EIGENVECTORS.append(mode) i += 1 # skip blank line EIGENVECTORS = np.array(EIGENVECTORS) # now we are ready to compute intensities. see # http://othes.univie.ac.at/10117/1/2010-05-05_0547640.pdf, page # 21. # I(\omega) = \sum_{\alpha=1}^3 | # \sum_{l=1}^M \sum_{\beta=1}^3 Z_{\alpha\beta}(l)e_{\beta}(l)|^2 # omega is the vibrational mode # alpha, beta are the cartesian polarizations # l is the atom number # e_beta is the eigenvector of the mode intensities = [] for mode in range(len(EIGENVECTORS)): S = 0 # This is the triple sum for alpha in [0, 1, 2]: s = 0 for l in [0, 1, 2]: # this is the atom number for beta in [0, 1, 2]: e = EIGENVECTORS[mode][l] Zab = BORN_MATRICES[l][alpha][beta] s += Zab * e[beta] S += s**2 intensities.append(S) intensities = np.array(intensities) / max(intensities) return intensities
from ase.ga.relax_attaches import VariansBreak from ase.constraints import FixAtoms from population import population from parallel_utilities import sync_atoms from gpaw import GPAW, FermiDirac, PoissonSolver, Mixer, PW from gpaw import extra_parameters extra_parameters['blacs'] = True from gpaw.utilities import h2gpts import traceback import sys import os import ase.parallel as mpi world = mpi.world traj = Trajectory('Pt10_5O2_Al2O3_KRRfund9l_DFTrelaxed.traj', 'w') for i in range(1, 4): data = [] stru = '../Pt10_5O2_{}/Pt10_5O2_Al2O3_KRRfund9l_DFTrelaxed.traj'.format(i) data = read(stru + '@:') data.sort(key=lambda x: x.get_potential_energy()) for j in range(0, len(data)): traj.write(data[j]) data1 = read('Pt10_5O2_Al2O3_KRRfund9l_DFTrelaxed.traj@:') data1.sort(key=lambda x: x.get_potential_energy()) traj = Trajectory('Pt10_5O2_Al2O3_KRRfund9l_DFTrelaxedsorted.traj', 'w') for j in range(0, len(data1)): traj.write(data1[j]) print(data1[j].get_potential_energy())
def dump_reference_json(): import ubjson from copy import copy from itertools import product sys.path.insert(0, os.path.join(root, "build/")) sys.path.insert(0, os.path.join(root, "tests/")) cutoffs = [2, 3] gaussian_sigmas = [0.2, 0.5] max_radials = [4] max_angulars = [3] cutoff_smooth_widths = [1.0] radial_basis = ["GTO", "DVR"] cutoff_function_types = ["ShiftedCosine", "RadialScaling"] fns = [ os.path.join(inputs_path, "CaCrP2O7_mvc-11955_symmetrized.json"), os.path.join(inputs_path, "small_molecule.json"), ] fns_to_write = [ os.path.join(read_inputs_path, "CaCrP2O7_mvc-11955_symmetrized.json"), os.path.join(read_inputs_path, "small_molecule.json"), ] np.random.seed(0) datasets_species = [1, 6, 7, 8, 15, 20, 24] projection_matrices = { str(sp): np.random.rand(max_angulars[0] + 1, max_radials[0], max_radials[0]).tolist() for sp in datasets_species } optimization = [ dict(), dict(Spline=dict(accuracy=1e-8)), dict( Spline=dict(accuracy=1e-8), RadialDimReduction=dict(projection_matrices=projection_matrices), ), ] data = dict( filenames=fns_to_write, cutoffs=cutoffs, gaussian_sigmas=gaussian_sigmas, max_radials=max_radials, rep_info=[], ) for fn in fns: for cutoff in cutoffs: data["rep_info"].append([]) for ( gaussian_sigma, max_radial, max_angular, cutoff_smooth_width, rad_basis, cutoff_function_type, opt_args, ) in product( gaussian_sigmas, max_radials, max_angulars, cutoff_smooth_widths, radial_basis, cutoff_function_types, optimization, ): frames = [read(fn)] if cutoff_function_type == "RadialScaling": cutoff_function_parameters = dict(rate=1, scale=cutoff * 0.5, exponent=3) else: cutoff_function_parameters = dict() hypers = { "interaction_cutoff": cutoff, "cutoff_smooth_width": cutoff_smooth_width, "max_radial": max_radial, "max_angular": max_angular, "gaussian_sigma_type": "Constant", "cutoff_function_type": cutoff_function_type, "cutoff_function_parameters": cutoff_function_parameters, "gaussian_sigma_constant": gaussian_sigma, "radial_basis": rad_basis, "optimization": opt_args, } sph_expn = SphericalExpansion(**hypers) expansions = sph_expn.transform(frames) x = expansions.get_features(sph_expn) x[np.abs(x) < 1e-300] = 0.0 data["rep_info"][-1].append( dict(feature_matrix=x.tolist(), hypers=copy(sph_expn.hypers))) with open( os.path.join(root, dump_path, "spherical_expansion_reference.ubjson"), "wb", ) as f: ubjson.dump(data, f)
#!/usr/bin/env python3 from ase import Atom from ase import Atoms from ase.io import read # Read structures Na6_lowest = read('christmas-tree.xyz') Na6_2nd_lowest = read('half-decahedron.xyz') # Get potential energies E_christmas = Na6_lowest.get_potential_energy() E_decahedron = Na6_2nd_lowest.get_potential_energy() print('Potential energy of the two most stable structures before relaxation') print('Christmas-tree: '+str(E_christmas)) print('Half_decahedron: '+str(E_decahedron))