def __init__(self, atoms, kpts=(1,1,1), run_type=None, input_data={}, xc='PBE', command=None, tprnfor=True, tstress=True, **kwargs): if command is None: command = 'mpirun -np $NCORES pw.x -in PREFIX.pwi > PREFIX.pwo' gbrv_pp = {} ppdir = os.environ['ESPRESSO_PSEUDO'] sym = list(set(atoms.get_chemical_symbols())) for s in sym: for f in os.listdir(ppdir): keys = f.split('_') if keys[0] == s.lower() and keys[1] == xc.lower(): gbrv_pp[s] = f indat = {'control':{'disk_io': 'none', 'restart_mode': 'from_scratch'}, 'system':{'ecutwfc': 40., 'ecutrho': 200., 'input_dft': xc, 'occupations': 'smearing', 'smearing': 'gaussian', 'degauss': 0.001}, 'electrons':{'electron_maxstep': 250, 'scf_must_converge': False, 'mixing_beta': 0.1, 'conv_thr': 1e-7}, } indat.update(input_data) Espresso.__init__(self, kpts=kpts, pseudopotentials=gbrv_pp, input_data=indat, tprnfor=tprnfor, tstress=tstress, **kwargs) self.command = command
def espresso_calculator(element): """ Preprocessor to generate input scrit file for Quantum Espresso code Returns the ESPRESSO calculator object """ pseudopotentials = { 'Ar': 'ar_pbe.UPF', 'Cu': 'cu_pbe.UPF', 'Li': 'li_pbe.UPF', 'N': 'n_pbe.UPF' } espresso_settings = { 'pseudo_dir': './', 'input_dft': 'RVV10', 'prefix': f'{element}', 'electron_maxstep': 100000, 'tstress': False, 'tprnfor': False, 'verbosity': 'low', 'occupations': 'smearing', 'degauss': 0.05, 'nspin': 2, 'starting_magnetization': 1, 'smearing': 'marzari-vanderbilt', 'ecutwfc': 100 } espresso_calculator = Espresso(restart=None, pseudopotentials=pseudopotentials, input_data=espresso_settings) return espresso_calculator
def calculate_target_repulsion(atoms, rc): N = len(atoms) pos = atoms.get_positions() sym = atoms.get_chemical_symbols() esp = 0.0 for sp in sym: espc = subprocess.getoutput( "awk '{if($1==\"" + str(sp) + "\"){print $2}}' energy_data_for_isolated_atom_references" ) #python3 esp += float(espc) # First perform a regular SCF run gbrv_pp = {} ppdir = os.environ['ESPRESSO_PSEUDO'] sym = list(set(atoms.get_chemical_symbols())) for s in sym: for f in os.listdir(ppdir): keys = f.split('_') if keys[0] == s.lower() and keys[1] == xc.lower(): gbrv_pp[s] = f calc = Espresso( kpts=(1, 1, 1), pseudopotentials=gbrv_pp, tstress=True, tprnfor=True, # kwargs added to parameters input_data=input_data) atoms.calc = calc e, f = 0., np.zeros((N, 3)) e = atoms.get_potential_energy() - esp print("cohesive energy [eV] = ", e) f = atoms.get_forces() powers = np.arange(6) #e, f = 0., np.zeros((N, 3)) #coeff = np.array([0., 0., 0., 14., -5., 2.]) #powers = np.arange(len(coeff)) #for i in range(N): # for j in range(N): # r = atoms.get_distance(i, j) # if sym[i] == sym[j] or r > rc: # continue # e += 0.5 * (coeff * (rc - r) ** powers).sum() # dedr = -coeff[1:] * powers[1:] * (rc - r) ** (powers[1:] - 1) # drdx = (pos[i] - pos[j]) / r # f[i] += -dedr.sum() * drdx return e, f
def test_main(): silicon = bulk('Si') calc = Espresso(pseudopotentials=PSEUDO, ecutwfc=50.0) silicon.set_calculator(calc) silicon.get_potential_energy() assert calc.get_fermi_level() is not None assert calc.get_ibz_k_points() is not None assert calc.get_eigenvalues(spin=0, kpt=0) is not None assert calc.get_number_of_spins() is not None assert calc.get_k_point_weights() is not None
def calc(self, **kwargs): from ase.calculators.espresso import Espresso command = '{} -in PREFIX.pwi > PREFIX.pwo'.format(self.executable) pseudopotentials = {} for path in self.pseudo_dir.glob('*.UPF'): fname = path.name # Names are e.g. si_lda_v1.uspp.F.UPF symbol = fname.split('_', 1)[0].capitalize() pseudopotentials[symbol] = fname kw = self._base_kw() kw.update(kwargs) return Espresso(command=command, pseudo_dir=str(self.pseudo_dir), pseudopotentials=pseudopotentials, **kw)
def qe_calc(): # set up executable label = 'scf' input_file = label + '.pwi' output_file = label + '.pwo' no_cpus = 1 pw = os.environ.get('PWSCF_COMMAND') os.environ['ASE_ESPRESSO_COMMAND'] = f'{pw} < {input_file} > {output_file}' # set up input parameters input_data = { 'control': { 'prefix': label, 'pseudo_dir': 'test_files/pseudos/', 'outdir': './out', 'calculation': 'scf' }, 'system': { 'ibrav': 0, 'ecutwfc': 20, 'ecutrho': 40, 'smearing': 'gauss', 'degauss': 0.02, 'occupations': 'smearing' }, 'electrons': { 'conv_thr': 1.0e-02, 'electron_maxstep': 100, 'mixing_beta': 0.7 } } # pseudo-potentials ion_pseudo = {'H': 'H.pbe-kjpaw.UPF', 'He': 'He.pbe-kjpaw_psl.1.0.0.UPF'} # create ASE calculator dft_calculator = Espresso(pseudopotentials=ion_pseudo, label=label, tstress=True, tprnfor=True, nosym=True, input_data=input_data, kpts=(1, 1, 1)) yield dft_calculator del dft_calculator
def main(): gold = bulk('Au') input_data = { 'system': { 'occupations': 'smearing', 'smearing': 'fermi-dirac', 'degauss': 0.02 } } calc = Espresso(pseudopotentials=PSEUDO, input_data=input_data) gold.set_calculator(calc) gold.get_potential_energy() assert calc.get_fermi_level() is not None assert calc.get_ibz_k_points() is not None assert calc.get_eigenvalues(spin=0, kpt=0) is not None assert calc.get_number_of_spins() is not None assert calc.get_k_point_weights() is not None
eV2Ry = 0.073498618 #| - QE Calculator pseudopotentials = { "C": "C.UPF", "Fe": "Fe.UPF", "H": "H.UPF", } calc = Espresso( kpts=(3, 3, 3), ecutwfc=400 * eV2Ry, # 'smearing', 'tetrahedra', 'tetrahedra_lin', 'tetrahedra_opt', 'fixed', 'from_input', occupations="smearing", # 'gaussian', 'methfessel-paxton', 'marzari-vanderbilt', 'fermi-dirac' smearing="gaussian", degauss=0.05 * eV2Ry, tstress=True, tprnfor=True, pseudopotentials=pseudopotentials, ) atoms.set_calculator(calc) # __| atoms.get_potential_energy() # try: # atoms.get_forces() # print("Getting forces worked!!") # except:
def prepare_calculator_from_namelist(namelist): """ PREPARE ASE CALCULATOR ====================== This function prepares the ASE calculator for the execution. It requires a namelist for the setup. Parameters ---------- namelist : dict The parsed namelist. Returns ------- ase_calc : The ASE calculator. """ # Check if the namelist has the correct keys if not __CALCULATOR_HEAD__ in namelist.keys(): raise ValueError( "Error, to setup a calculator the section %s must be declared." % __CALCULATOR_HEAD__) c_info = namelist[__CALCULATOR_HEAD__] ks = c_info.keys() # Check if the disable check is present check = True if __DISABLE_CHECK__ in ks: check = bool(c_info[__DISABLE_CHECK__]) # Define defaults KPTS = (1, 1, 1) KOFFS = (0, 0, 0) # Get the keywords if __KPTS_HEAD__ in ks: KPTS = [int(x) for x in c_info[__KPTS_HEAD__]] if len(KPTS) != 3: raise ValueError("Error, %s must be a 3 dimensional list" % __KPTS_HEAD__) if __KOFF_HEAD__ in ks: KOFFS = [int(x) for x in c_info[__KOFF_HEAD__]] if len(KOFFS) != 3: raise ValueError("Error, %s must be a 3 dimensional list" % __KOFF_HEAD__) # Setup the pseudopotentials pseudopotentials = {} pseudo_keys = [x for x in ks if __PSEUDO_LIST__ in x] for pkey in pseudo_keys: pvalue = c_info[pkey] patom = pkey.replace(__PSEUDO_LIST__, "", 1) patom = patom[0].upper() + patom[1:] pseudopotentials[patom] = pvalue is_binary = False if __BINARY__ in ks: is_binary = True binary = c_info[__BINARY__] # Setup the calculator ase_calc = None tot_keys = __ALLOWED_KEYS__ if __CALCULATOR_TYPE__ in ks: if not c_info[__CALCULATOR_TYPE__] in __CALCULATOR_SYNONIMOUS__.keys(): print("List of supported calculators:", __CALCULATOR_SYNONIMOUS__.keys) raise ValueError( "Error, the specified calculator '%s' is not in supported." % c_info[__CALCULATOR_TYPE__]) calc = __CALCULATOR_SYNONIMOUS__[c_info[__CALCULATOR_TYPE__]] if calc == __CALC_QE__: tot_keys = __ALLOWED_KEYS__ + __QE_ALLOWED_KEYS__ # Check all the qe allowed keys input_data = {} qe_keys = [x for x in __QE_ALLOWED_KEYS__ if x in ks] for x in qe_keys: input_data[x] = c_info[x] ase_calc = Espresso(pseudopotentials=pseudopotentials, input_data=input_data, kpts=KPTS, koffset=KOFFS) if is_binary: ase_calc.command = binary # Check the allowed keys for k in ks: if __PSEUDO_LIST__ in k: continue if (not k in tot_keys) and check: print("Error with the key:", k) print("Did you mean something like:", difflib.get_close_matches(k, tot_keys)) raise IOError("Error in calculator namespace: key '" + k + "' not recognized.") # Check for mandatory keys for req_key in __REQUESTED_KEYS__: if not req_key in ks: raise IOError( "Error, the calculator configuration namelist requires the keyword: '" + req_key + "'") return ase_calc
### Constraints ### from ase.constraints import FixAtoms z_atoms = atoms_info.get_positions()[:, 2] ase_union.set_constraint( FixAtoms(indices=np.where(z_atoms <= z_bottom_2nd[1])[0])) ### Quantum Espresso ### from ase.calculators.espresso import Espresso calculation = input_sol["control"]["calculation"] kpts = input_ase["kpts"] command = input_ase["command"] if calculation == 'scf': qe = Espresso(input_data=input_sol, pseudopotentials=pseudopotentials, kpts=kpts, command=command) elif calculation == 'relax': qe = Espresso(input_data=input_sol, pseudopotentials=pseudopotentials, kpts=kpts, command=command) elif calculation == 'bands': qe = Espresso(input_data=input_sol, pseudopotentials=pseudopotentials, kpts=kpts, command=command) ase_union.calc = qe ase_union.calc.write_input(atoms_info) try: ase_union.get_potential_energy() # run pw.x
pw_data['diagonalization'] = 'david' pw_data['diago_david_ndim'] = 2 pw_data['mixing_beta'] = 0.2 pw_data['mixing_mode'] = 'local-TF' pw_data['electron_maxstep'] = 500 pseudos = {} pseudos['Rh'] = 'Rh_ONCV_PBE-1.0.oncvpsp.UPF' pseudos['C'] = 'C.pbe-n-kjpaw_psl.1.0.0.UPF' pseudos['O'] = 'O.pbe-n-kjpaw_psl.0.1.UPF' pseudos['H'] = 'H.pbe-rrkjus_psl.1.0.0.UPF' pseudos['H'] = 'Al.pbe-n-kjpaw_psl.1.0.0.UPF' calc = Espresso(input_data = pw_data, pseudopotentials = pseudos, kpts = kpts) atoms.set_calculator(calc) ################################################################################ # WRITE ESPRESSO INPUT ################################################################################ write_esperesso_input = True if write_esperesso_input is True: calc.write_input(atoms) os.rename('espresso.pwi', 'pw.inp') ################################################################################
def get_potential_energy(self, atoms=None, force_consistent=True): return Espresso.get_potential_energy(self, atoms=atoms)
# by default ase will look for them in $HOME/espresso/pseudo pseudo = {"H": "H.pbe-rrkjus_psl.0.1.UPF", "O": "O.pbe-n-rrkjus_psl.0.1.UPF"} # Setup some info on the calculator (the wavefunction and density cutoff) # Note they are super below convergence # Good values would be (45, 45*8) for the cutoffs, and (3,3,2) for the k points esp_info = {"ecutwfc": 25, "ecutrho": 25 * 4, "disk_io": "none"} K_POINTS = (1, 1, 1) # Only gamma calculation # Setup the quantum espresso command for run (parallel on 4 processors here) cmd = "/usr/bin/mpirun -np 2 $HOME/Downloads/QuantumESPRESSO/qe-6.3/bin/pw.x -in PREFIX.pwi > PREFIX.pwo" # Setup the calculator calc = Espresso(pseudopotentials=pseudo, tstress=True, tprnfor=True, kpts=K_POINTS, input_data=esp_info, command=cmd) #Now load the initial dynamical matrix dyn_start = CC.Phonons.Phonons("../ensemble_data_test/dyn") T = 0 # Temperature of the calculation N_RAND = 500 # number of random configurations # Setup the ensemble ens = sscha.Ensemble.Ensemble(dyn_start, T) # Generate the ensemble ens.generate(N_RAND) # Get forces and energy using the quantum espresso calculator
#os.environ['ASE_ESPRESSO_COMMAND'] = 'srun -n {0} --mpi=pmi2 {1} -npool {2} < {3} > {4}'.format(no_cpus, # pw_loc, npool, input_file_name, output_file_name) os.environ['ASE_ESPRESSO_COMMAND'] = '{0} < {1} > {2}'.format(pw_loc, input_file_name, output_file_name) # set up input parameters input_data = {'control': {'prefix': label, 'pseudo_dir': 'test_files/pseudos/', 'outdir': './out', #'verbosity': 'high', 'calculation': 'scf'}, 'system': {'ibrav': 0, 'ecutwfc': 20, # 45, 'ecutrho': 40, # 181, 'smearing': 'gauss', 'degauss': 0.02, 'occupations': 'smearing'}, 'electrons': {'conv_thr': 1.0e-03, #'startingwfc': 'file', 'electron_maxstep': 100, 'mixing_beta': 0.5}} # pseudo-potentials ion_pseudo = {'Ag': 'Ag.pbe-n-kjpaw_psl.1.0.0.UPF', 'I': 'I.pbe-n-kjpaw_psl.1.0.0.UPF'} # create ASE calculator dft_calc = Espresso(pseudopotentials=ion_pseudo, label=label, tstress=True, tprnfor=True, nosym=True, #noinv=True, input_data=input_data, kpts=(1,1,1)) dft_calc.parameters['parallel'] = False
###DFT Setup, Optimization, and Plotting pseudopotentials = {'Al': pot_file2} input_data = { 'system': { 'ecutwfc': 29, 'ecutrho': 143, 'occupations': 'smearing', 'smearing': 'mp', 'degauss': 0.02 }, 'disk_io': 'low' } calc = Espresso(pseudopotentials=pseudopotentials, tstress=True, tprnfor=True, kpts=(4, 4, 1), input_data=input_data) for image in imagesEAM: image.set_calculator( Espresso(pseudopotentials=pseudopotentials, tstress=True, tprnfor=True, kpts=(4, 4, 1), input_data=input_data)) print(imagesEAM[len(imagesEAM) - 1].get_potential_energy()) pes = np.zeros(no_images) pos = np.zeros((no_images, len(imagesEAM[0]), 3)) DFTForces = np.zeros((no_images, len(imagesEAM[0]), 3))
no_cpus = 32 npool = 32 pw_loc = os.environ.get('PWSCF_COMMAND') #pw_loc = '/n/home08/xiey/q-e/bin/pw.x' os.environ['ASE_ESPRESSO_COMMAND'] = 'srun -n {0} --mpi=pmi2 {1} -npool {2} < {3} > {4}'.format(no_cpus, pw_loc, npool, input_file_name, output_file_name) #os.environ['ASE_ESPRESSO_COMMAND'] = '{0} < {1} > {2}'.format(pw_loc, input_file_name, output_file_name) # set up input parameters input_data = {'control': {'prefix': label, 'pseudo_dir': './', 'outdir': './out', #'verbosity': 'high', 'calculation': 'scf'}, 'system': {'ibrav': 0, 'ecutwfc': 60, 'ecutrho': 360}, 'electrons': {'conv_thr': 1.0e-9, #'startingwfc': 'file', 'electron_maxstep': 100, 'mixing_beta': 0.7}} # pseudo-potentials ion_pseudo = {'C': 'C.pz-rrkjus.UPF'} # create ASE calculator dft_calc = Espresso(pseudopotentials=ion_pseudo, label=label, tstress=True, tprnfor=True, nosym=True, #noinv=True, input_data=input_data, kpts=(8, 8, 8))
# In this example we use a UNIX socket. See other examples for INET socket. # UNIX sockets are faster then INET sockets, but cannot run over a network. # UNIX sockets are files. The actual path will become /tmp/ipi_ase_espresso. unixsocket = 'ase_espresso' # Configure pw.x command for UNIX or INET. # # UNIX: --ipi {unixsocket}:UNIX # INET: --ipi {host}:{port} # # See also QE documentation, e.g.: # # https://www.quantum-espresso.org/Doc/pw_user_guide/node13.html # command = ('pw.x < PREFIX.pwi --ipi {unixsocket}:UNIX > PREFIX.pwo'.format( unixsocket=unixsocket)) espresso = Espresso(command=command, ecutwfc=30.0, pseudopotentials=pseudopotentials, pseudo_dir=pseudo_dir) opt = BFGS(atoms, trajectory='opt.traj', logfile='opt.log') with SocketIOCalculator(espresso, log=sys.stdout, unixsocket=unixsocket) as calc: atoms.calc = calc opt.run(fmax=0.05) # Note: QE does not generally quit cleanly - expect nonzero exit codes.
def read_pw_in(fileobj): """Parse a Quantum ESPRESSO input files, '.in', '.pwi'. ESPRESSO inputs are generally a fortran-namelist format with custom blocks of data. The namelist is parsed as a dict and an atoms object is constructed from the included information. Parameters ---------- fileobj : file | str A file-like object that supports line iteration with the contents of the input file, or a filename. Returns ------- atoms : Atoms Structure defined in the input file. Raises ------ KeyError Raised for missing keys that are required to process the file """ # TODO: use ase opening mechanisms if isinstance(fileobj, str): fileobj = open(fileobj, 'rU') # parse namelist section and extract remaining lines data, card_lines = read_fortran_namelist(fileobj) # get the cell if ibrav=0 if 'system' not in data: raise KeyError('Required section &SYSTEM not found.') elif 'ibrav' not in data['system']: raise KeyError('ibrav is required in &SYSTEM') elif data['system']['ibrav'] == 0: # celldm(1) is in Bohr, A is in angstrom. celldm(1) will be # used even if A is also specified. if 'celldm(1)' in data['system']: alat = data['system']['celldm(1)'] * units['Bohr'] elif 'A' in data['system']: alat = data['system']['A'] else: alat = None cell, cell_alat = get_cell_parameters(card_lines, alat=alat) else: alat, cell = ibrav_to_cell(data['system']) positions_card = get_atomic_positions(card_lines, n_atoms=data['system']['nat'], cell=cell, alat=alat) symbols = [label_to_symbol(position[0]) for position in positions_card] tags = [label_to_tag(position[0]) for position in positions_card] positions = [position[1] for position in positions_card] constraint_idx = [position[2] for position in positions_card] constraint = get_constraint(constraint_idx) pseudos = get_pseudopotentials(card_lines, n_types=data['system']['ntyp']) # Switch from using 'input_data' to a flat dictionary data = {k: v for block in data.values() for k, v in block.items()} # Don't store ntyp and nat because these are derivable from the atoms object data.pop('ntyp', None) data.pop('nat', None) # TODO: put more info into the atoms object # e.g magmom, forces. atoms = Atoms(symbols=symbols, positions=positions, cell=cell, constraint=constraint, pbc=True, tags=tags, calculator=Espresso(pseudopotentials=pseudos, **data)) atoms.calc.atoms = atoms if any(['k_points' in l.lower() for l in card_lines]): for k, v in zip(['kpts', 'koffset', 'gamma_only'], get_kpoints(card_lines, cell=atoms.cell)): atoms.calc.parameters[k] = v return atoms
'tprnfor': True, 'outdir': 'qe_at_gamma', 'input_data': { 'system': { 'ecutwfc': 16.0 }, 'electrons': { 'conv_thr': 1e-10, 'mixing_beta': 0.5 }, 'disk_io': 'low', 'pseudo_dir': 'potentials' }, 'kpts': None, } calc = Espresso(**calculator_inputs) if not os.path.exists('structures'): os.mkdir('structures/') # Generate initial structure atoms_prim = bulk('Si', 'diamond', a=a0) n_prim = atoms_prim.get_masses().shape[0] # Replicate the unit cell 'nrep'=3 times nrep = 3 supercell = np.array([nrep, nrep, nrep]) initial_structure = atoms_prim.copy() * (supercell[0], 1, 1) * ( 1, supercell[1], 1) * (1, 1, supercell[2]) replicated_structure = initial_structure.copy() ######## Set up the standard rattle (random displacement) scheme ####### # seed_int_struct = np.random.randint(1, 100000, size=1, dtype=np.int64)[0]
# Prepare the espresso calculator # NOTE: these files should be located in the cluster $HOME/espresso/pseudo directory pseudo = {"H": "H.pbe-rrkjus_psl.0.1.UPF", "O": "O.pbe-n-rrkjus_psl.0.1.UPF"} input_data = {"ecutwfc" : 45, "ecutrho" : 45*8, "conv_thr" : 1e-8, "occupations" : "fixed", "tstress" : True, "diskio" : "none", "tprnfor" : True} KPTS = (3,3,2) # K points calc = Espresso(input_data = input_data, pseudopotentials = pseudo, kpts = KPTS) # Prepare the cluster # marconi (setted from .ssh_config) => [email protected] # No pwd, login with private key cluster = sscha.Cluster.Cluster("marconi", partition_name="knl_usr_prod", binary="$HOME/qe-6.2.1/bin/pw.x -npool $NPOOL -i PREFIX.pwi > PREFIX.pwo") # Setup the working directory cluster.workdir = "/marconi_work/IscrC_HydPD/tmp_calc" cluster.n_nodes = 1 cluster.n_cpu = 32 cluster.account_name = "IscrB_COMRED" cluster.n_pool = 4 cluster.load_modules = """module load autoload intel module load autoload intelmpi
from ase.collections import dcdft from ase.io import read, write, Trajectory # making dimer.traj traj = Trajectory('dimer.traj', 'w') # create Trajectory object dx = 0.1 #scaling factor list1 = [0, 0, 0] # position of first atom list2 = [0, 0, 0.5] # will store new position of second atom vec_2 = np.array(list2) - np.array(list1) # vector pointing from 1 to 2 norm_2 = np.linalg.norm(vec_2, ord=2) # get norm vec_2 = [x / norm_2 for x in vec_2] # get unit vector for i in range(4): ss = [dx * x for x in vec_2] #scale vector list2 = np.array(list2) + np.array(ss) # move second atom dimer = Atoms('CC', positions=[list1, list2]) # create ASE atom object dimer.calc = Espresso(pseudopotentials=pseudopotentials) dft_energy = dimer.get_potential_energy() traj.write(dimer, energy=(dft_energy)) # write dft energy to trajectory file dx += 0.1 # making bulk.traj #https://wiki.fysik.dtu.dk/ase/tutorials/deltacodesdft/deltacodesdft.html?highlight=dft%20calculatin#ase.utils.deltacodesdft.delta pseudopotentials = {'C': 'C.pbe-n-kjpaw_psl.1.0.0.UPF'} for symbol in ['C']: traj = Trajectory('bulk.traj'.format(symbol), 'w') for s in range(94, 108, 2): bulk = dcdft[symbol] bulk.set_cell(bulk.cell * (s / 100.0)**(1.0 / 3.0), scale_atoms=True) bulk.calc = Espresso(pseudopotentials=pseudopotentials, kpts=(6, 6, 6)) dft_energy = bulk.get_potential_energy()
"S": "S.pbe-nl-rrkjus_psl.1.0.0.UPF" } input_data = { "ecutwfc": 35, "ecutrho": 350, "occupations": "smearing", "input_dft": "blyp", "mixing_beta": 0.2, "conv_thr": 1e-9, "degauss": 0.02, "smearing": "mp", "pseudo_dir": "." } calc = Espresso(pseudopotentials=pseudo, input_data=input_data, kspacing=0.06) struct = CC.Structure.Structure() struct.read_scf("H3S.scf") ase_struct = struct.get_ase_atoms() ase_struct.set_calculator(calc) print("Computing the total energy...") total_energy = ase_struct.get_total_energy() phonons = """ &inputph ldisp = .true. nq1 = 2 nq2 = 2
# %cd /content !mkdir NaCl # %cd NaCl #---- !wget https://www.quantum-espresso.org/upf_files/Na.pbesol-spn-kjpaw_psl.1.0.0.UPF !wget https://www.quantum-espresso.org/upf_files/Cl.pbesol-n-kjpaw_psl.1.0.0.UPF #---- from ase.build import bulk from ase.calculators.espresso import Espresso from ase.constraints import UnitCellFilter from ase.optimize import LBFGS import ase.io pseudopotentials = {'Na': 'Na.pbesol-spn-kjpaw_psl.1.0.0.UPF', 'Cl': 'Cl.pbesol-n-kjpaw_psl.1.0.0.UPF'} rocksalt = bulk('NaCl', crystalstructure='rocksalt', a=6.0) calc = Espresso(pseudopotentials=pseudopotentials,pseudo_dir = './', tstress=True, tprnfor=True, kpts=(3, 3, 3)) rocksalt.set_calculator(calc) ucf = UnitCellFilter(rocksalt) opt = LBFGS(ucf) opt.run(fmax=0.005) # cubic lattic constant print((8*rocksalt.get_volume()/len(rocksalt))**(1.0/3.0)) #---- # %cd /content !mkdir Cu # %cd Cu #---- !wget https://www.quantum-espresso.org/upf_files/Cu.pz-d-rrkjus.UPF #---- from ase import Atoms from ase.build import bulk
from ase.calculators.espresso import Espresso pot_file = 'Al.pbe-n-rrkjus_psl.1.0.1.UPF' pseudopotentials = {'Al': pot_file} input_data = { 'system': { 'ecutwfc': 29, 'ecutrho': 143, 'occupations': 'smearing', 'smearing': 'mp', 'degauss': 0.02 }, 'disk_io': 'low' } calc = Espresso(pseudopotentials=pseudopotentials, tstress=True, tprnfor=True, kpts=(4, 4, 1), input_data=input_data) #create structure as FCC surface with addsorbate from ase.build import fcc111, add_adsorbate slab = fcc111('Al', size=(2, 2, 3)) add_adsorbate(slab, 'Al', 2, 'hcp') slab.center(vacuum=5.0, axis=2) #view and set calculator from ase.visualize import view view(slab, viewer='x3d') slab.set_calculator(calc) slab.get_potential_energy()
stretch_max=0.15, toll_rotation=5e-2) kpts = calculate_kpts(atoms=atoms, cell=support.cell, kpts=kpts, scale_kpts='xy') ################################################################################ # WRITE QUANTUM ESPRESSO INPUT ################################################################################ calc = Espresso(input_data=input_data, pseudopotentials=pseudos, kpts=kpts, koffset=koffset, calculation='vc-relax', restart_mode='from_scratch', max_seconds=1700) calc.write_input(atoms) os.rename('espresso.pwi', 'pw.inp') ################################################################################ # RUN QUANTUM ESPRESSO ################################################################################ run_qe = False if run_qe is True: os.system("run pw -fs -n=2 -t=0.5")
# -*- coding: utf-8 -*- """ Created on Sun Feb 9 16:28:02 2020 @author: srava """ from ase.build import molecule, bulk from ase.visualize import view from ase.optimize import BFGSLineSearch, QuasiNewton from ase.calculators.espresso import Espresso from ase.constraints import UnitCellFilter from ase.optimize import LBFGS pseudopotentials = { 'Na': 'Na_pbe_v1.uspp.F.UPF', 'Cl': 'Cl.pbe-n-rrkjus_psl.1.0.0.UPF' } rocksalt = bulk('NaCl', crystalstructure='rocksalt', a=6.0) calc = Espresso(pseudopotentials=pseudopotentials, tstress=True, tprnfor=True, kpts=(3, 3, 3)) rocksalt.calc = calc ucf = UnitCellFilter(rocksalt) opt = LBFGS(ucf) opt.run(fmax=0.005) # cubic lattic constant print((8 * rocksalt.get_volume() / len(rocksalt))**(1.0 / 3.0))
'input_dft': xc, 'occupations': 'smearing', 'smearing': 'gaussian', 'degauss': 0.001 }, 'electrons': { 'electron_maxstep': 250, 'scf_must_converge': False, 'mixing_beta': 0.1, 'conv_thr': 1e-7 }, } calc = Espresso( kpts=kpts, pseudopotentials=gbrv_pp, tstress=True, tprnfor=True, # kwargs added to parameters input_data=input_data) atoms.calc = calc atoms.get_potential_energy() # Get the valence band maximum efermi = calc.get_fermi_level() Nk = len(calc.get_ibz_k_points()) Ns = calc.get_number_of_spins() eigval = np.array([[calc.get_eigenvalues(kpt=k, spin=s) for k in range(Nk)] for s in range(Ns)]) evbm = np.max(eigval[eigval < efermi]) # Next, a band structure calculation
pseudopotentials = {"H": "H.pbe-kjpaw_psl.0.1.UPF", "O": "O.pbe-n-kjpaw_psl.0.1.UPF"} import ase.io from ase.calculators.espresso import Espresso from ase.optimize import LBFGS input_data = { 'system': { 'ecutwfc': 30.0, 'ecutrho': 120.0 }, 'disk_io': 'none', 'pseudo_dir': '/home/efefer/pseudo/PSLIB' } calc = Espresso(pseudopotentials=pseudopotentials, tstress=True, tprnfor=True, input_data=input_data) atoms = ase.io.read("H2O_centered.xyz") atoms.calc = Espresso(pseudopotentials=pseudopotentials, tstress=True, tprnfor=True) opt = LBFGS(atoms) opt.run(fmax=0.005)