def gen_test_data(datadir: str, params_fd: dict, supercell):
    from gpaw.elph.electronphonon import ElectronPhononCoupling

    params_gs = copy.deepcopy(params_fd)

    atoms = Cluster(ase.build.bulk('C'))

    calc_gs = GPAW(**params_gs)
    atoms.calc = calc_gs
    atoms.get_potential_energy()
    atoms.calc.write("gs.gpw", mode="all")

    # Make sure the real space grid matches the original.
    # (basically we multiply the number of grid points in each dimension by the supercell dimension)
    params_fd['gpts'] = calc_gs.wfs.gd.N_c * list(supercell)
    if 'h' in params_fd:
        del params_fd['h']
    del calc_gs

    if world.rank == 0:
        os.makedirs(datadir, exist_ok=True)
    calc_fd = GPAW(**params_fd)
    elph = ElectronPhononCoupling(atoms,
                                  calc=calc_fd,
                                  supercell=supercell,
                                  calculate_forces=True,
                                  name=f'{datadir}/elph')
    elph.run()
    calc_fd.wfs.gd.comm.barrier()
    elph = ElectronPhononCoupling(atoms, calc=calc_fd, supercell=supercell)
    elph.set_lcao_calculator(calc_fd)
    elph.calculate_supercell_matrix(dump=1)
Example #2
0
from ase.build import molecule
from ase import optimize
from ase.vibrations.infrared import InfraRed

from gpaw.cluster import Cluster
from gpaw import GPAW, FermiDirac

h = 0.22

atoms = Cluster(molecule('H2'))
atoms.minimal_box(3.5, h=h)

# relax the molecule
calc = GPAW(h=h, occupations=FermiDirac(width=0.1))
atoms.calc = calc
dyn = optimize.FIRE(atoms)
dyn.run(fmax=0.05)
atoms.write('relaxed.traj')

# finite displacement for vibrations
ir = InfraRed(atoms)
ir.run()
Example #3
0
def main__raman_ch4(structure, supercell, log):
    import ase.build

    from gpaw.lrtddft.spectrum import polarizability
    from gpaw.cluster import Cluster
    from gpaw import GPAW, FermiDirac

    #=============================================
    # Settings

    # Input structure
    relax_grid_sep = 0.22  # GPAW finite grid size
    vacuum_sep = 3.5
    pbc = False
    if structure == 'ch4':
        def get_unrelaxed_structure():
            atoms = Cluster(ase.build.molecule('CH4'))
            atoms.minimal_box(vacuum_sep, h=relax_grid_sep)
            return atoms
    elif structure == 'mos2':
        def get_unrelaxed_structure():
            atoms = Cluster(ase.build.mx2('MoS2'))
            atoms.center(vacuum=vacuum_sep, axis=2)
            return atoms

    # Calculator (general settings)
    make_calc = functools.partial(GPAW,
            occupations=FermiDirac(width=0.1),
            symmetry={'point_group': False},
            txt=log,
    )

    # Relaxation settings
    make_calc_relax = functools.partial(make_calc,
            h=relax_grid_sep,
    )

    # Args for computations on displaced structures
    raman_grid_sep = 0.25 # In the example, they use a larger spacing here than during relaxation.
                          # (TODO: but why? On CH4 I observe that this to leads to equilibrium forces of
                          #        0.067 ev/A, which seems to compromise our "energy minimum" state...)
    num_converged_bands = 10
    num_total_bands = 20
    make_calc_raman = functools.partial(make_calc,
            h=raman_grid_sep,
            convergence={
                'eigenstates': 1.e-5,
                'bands': num_converged_bands,
            },
            eigensolver='cg',
            nbands=num_total_bands,
    )
    supercell_matrix = [[supercell[0], 0, 0], [0, supercell[1], 0], [0, 0, supercell[2]]]
    displacement_distance = 1e-2

    # ----------
    # Excitation settings (for polarizability)
    ex_kw = {'restrict': {'jend':num_converged_bands-1}}
    omega = 5.0 # eV
    get_polarizability = functools.partial(polarizability, omega=omega, form='v', tensor=True)
    subtract_equilibrium_polarizability = False

    #=============================================
    # Process

    disp_filenames = {
        'ex': {'eq': 'raman-eq.ex.gz', 'disp': 'raman-{:04}.ex.gz'},
        'force': {'eq': 'force-set-eq.npy', 'disp': 'force-set-{:04}.npy'},
    }

    # Relax
    unrelaxed_atoms = get_unrelaxed_structure()
    unrelaxed_atoms.pbc = pbc
    unrelaxed_atoms.calc = make_calc_relax()
    relax_atoms(outpath='relaxed.vasp', atoms=unrelaxed_atoms)

    # Phonopy displacements
    phonon = get_minimum_displacements(cachepath='phonopy_disp.yaml',
            unitcell=phonopy.interface.calculator.read_crystal_structure('relaxed.vasp', interface_mode='vasp')[0],
            supercell_matrix=supercell_matrix,
            displacement_distance=displacement_distance,
    )

    # Computing stuff at displacements
    eq_atoms = Cluster(phonopy_atoms_to_ase(phonon.supercell))
    eq_atoms.pbc = pbc
    if raman_grid_sep != relax_grid_sep:
        eq_atoms.minimal_box(vacuum_sep, h=raman_grid_sep)
    eq_atoms.calc = make_calc_raman()

    force_sets = make_force_sets_and_excitations(cachepath='force-sets.npy',
            disp_filenames=disp_filenames, phonon=phonon,
            atoms=eq_atoms, ex_kw=ex_kw,
    )
    phonon.set_forces(force_sets)

    # Applying symmetry
    cart_pol_derivs = expand_raman_by_symmetry(cachepath='raman-cart.npy',
            phonon=phonon,
            disp_filenames=disp_filenames, get_polarizability=get_polarizability, ex_kw=ex_kw,
            subtract_equilibrium_polarizability=subtract_equilibrium_polarizability,
    )

    # Phonopy part 2
    gamma_eigendata = get_eigensolutions_at_q(cachepath='eigensolutions-gamma.npz',
            phonon=phonon, q=[0, 0, 0],
    )

    # Raman of modes
    get_mode_raman(outpath='mode-raman-gamma.npy',
            eigendata=gamma_eigendata, cart_pol_derivs=cart_pol_derivs,
    )
Example #4
0
epsinf = 78.36
rhomin = 0.0001 / Bohr**3
rhomax = 0.0050 / Bohr**3
st = 50. * 1e-3 * Pascal * m
p = -0.35 * 1e9 * Pascal
convergence = {
    'energy': 0.05 / 8.,
    'density': 10.,
    'eigenstates': 10.,
}

atoms = Cluster(molecule('H2O'))
atoms.minimal_box(vac, h)

if not SKIP_VAC_CALC:
    atoms.calc = GPAW(xc='PBE', h=h, convergence=convergence)
    Evac = atoms.get_potential_energy()
    print(Evac)
else:
    # h=0.24, vac=4.0, setups: 0.9.11271, convergence: only energy 0.05 / 8
    Evac = -14.857414548

with warnings.catch_warnings():
    # ignore production code warning for ADM12PoissonSolver
    warnings.simplefilter("ignore")
    psolver = ADM12PoissonSolver()

atoms.calc = SolvationGPAW(xc='PBE',
                           h=h,
                           poissonsolver=psolver,
                           convergence=convergence,
Example #5
0
epsinf = 78.36
rho0 = 0.00078 / Bohr**3
beta = 1.3
st = 72. * 1e-3 * Pascal * m
convergence = {
    'energy': 0.05 / 8.,
    'density': 10.,
    'eigenstates': 10.,
}

atoms = Cluster(Atoms('Cl'))
atoms.minimal_box(vac, h)

if not SKIP_VAC_CALC:
    atoms.calc = GPAW(xc='PBE', h=h, charge=-1, convergence=convergence)
    Evac = atoms.get_potential_energy()
    print(Evac)
else:
    # h=0.24, vac=4.0, setups: 0.9.11271, convergence: only energy 0.05 / 8
    Evac = -3.83245253419

atoms.calc = SolvationGPAW(
    xc='PBE',
    h=h,
    charge=-1,
    convergence=convergence,
    cavity=FG02SmoothStepCavity(rho0=rho0,
                                beta=beta,
                                density=ElDensity(),
                                surface_calculator=GradientSurface()),
Example #6
0
T = 298.15
vdw_radii = vdw_radii.copy()
vdw_radii[1] = 1.09
atomic_radii = lambda atoms: [vdw_radii[n] for n in atoms.numbers]
convergence = {
    'energy': 0.05 / 8.,
    'density': 10.,
    'eigenstates': 10.,
}

atoms = Cluster(molecule('H2O'))
atoms.minimal_box(vac, h)
atoms.pbc = True

with warnings.catch_warnings():
    # ignore production code warning for ADM12PoissonSolver
    warnings.simplefilter("ignore")
    psolver = ADM12PoissonSolver(eps=1e-7)

atoms.calc = SolvationGPAW(
    xc='LDA', h=h, convergence=convergence,
    cavity=EffectivePotentialCavity(
        effective_potential=Power12Potential(atomic_radii=atomic_radii, u0=u0),
        temperature=T
    ),
    dielectric=LinearDielectric(epsinf=epsinf),
    poissonsolver=psolver
)
atoms.get_potential_energy()
atoms.get_forces()
Example #7
0
SKIP_VAC_CALC = True

h = 0.24
vac = 4.0
convergence = {
    'energy': 0.05 / 8.,
    'density': 10.,
    'eigenstates': 10.,
}

atoms = Cluster(molecule('H2O'))
atoms.minimal_box(vac, h)

if not SKIP_VAC_CALC:
    atoms.calc = GPAW(xc='PBE', h=h, convergence=convergence)
    Evac = atoms.get_potential_energy()
    print(Evac)
else:
    # h=0.24, vac=4.0, setups: 0.9.11271, convergence: only energy 0.05 / 8
    Evac = -14.857414548

atoms.calc = SolvationGPAW(
    xc='PBE', h=h, convergence=convergence,
    **get_HW14_water_kwargs()
)
Ewater = atoms.get_potential_energy()
Eelwater = atoms.calc.get_electrostatic_energy()
Esurfwater = atoms.calc.get_solvation_interaction_energy('surf')
atoms.get_forces()
DGSol = (Ewater - Evac) / (kcal / mol)
Example #8
0
atoms2 = atoms.copy()
atoms2.set_initial_magnetic_moments(None)

atomss = (atoms, atoms2)
Es = []
Fs = []

for atoms in atomss:
    atoms.calc = SolvationGPAW(
        xc='LDA',
        h=h,
        charge=-1,
        cavity=EffectivePotentialCavity(effective_potential=Power12Potential(
            atomic_radii, u0),
                                        temperature=T,
                                        surface_calculator=GradientSurface(),
                                        volume_calculator=KB51Volume()),
        dielectric=LinearDielectric(epsinf=epsinf),
        interactions=[
            SurfaceInteraction(surface_tension=100. * 1e-3 * Pascal * m),
            VolumeInteraction(pressure=-1.0 * 1e9 * Pascal),
            LeakedDensityInteraction(voltage=1.0)
        ])
    Es.append(atoms.get_potential_energy())
    Fs.append(atoms.get_forces())

# compare to expected difference of a gas phase calc
print('difference E: ', Es[0] - Es[1])
equal(Es[0], Es[1], 0.0002)
print('difference F: ', np.abs(Fs[0] - Fs[1]).max())
equal(Fs[0], Fs[1], 0.003)