示例#1
0
 def test_bs(self):
     sb = StructureBuilder()
     atoms, *_ = sb.get_structure("C", "diamond")
     # print(atoms)
     base_dir = os.path.join(os.path.dirname(__file__),
                             "../../tmp/C-class/")
     m_calc = MaterCalc(atoms=atoms,
                        base_dir=base_dir)
     self.assertTrue(m_calc.relax(fmax=0.002))  # Very tight limit!
     self.assertTrue(m_calc.ground_state())
     # get the PBE BS
     lattice_type = get_cellinfo(m_calc.atoms.cell).lattice
     self.assertTrue(lattice_type in special_paths.keys())
     kpts_bs = dict(path=special_paths[lattice_type],
                    npoints=120)
     # HSE06 base generate
     gs_file = os.path.join(base_dir, "gs.gpw")
     _calc = GPAW(restart=gs_file)
     atoms = _calc.atoms.copy()
     calc = GPAW(**_calc.parameters)
     calc.set(kpts=dict(gamma=True,
                        density=4))  # low density calculations
     calc.atoms = atoms
     del _calc
     calc.get_potential_energy()
     calc.write(os.path.join(base_dir, "hse.gpw"), mode="all")
     calc = GPAW(restart=os.path.join(base_dir, "hse.gpw"),
                 txt=None)
     ns = calc.get_number_of_spins()
     nk = len(calc.get_ibz_k_points())
     nbands = calc.get_number_of_bands()
     eigen_pbe = numpy.array([[calc.get_eigenvalues(spin=s,
                                                    kpt=k) \
                               for k in range(nk)]\
                              for s in range(ns)])
     parprint("EIGEN_PBE", eigen_pbe.shape)
     vxc_pbe = vxc(calc, "PBE")
     parprint("VXC_PBE", vxc_pbe.shape)
     # world.barrier()
     # HSE06 now
     calc_hse = EXX(os.path.join(base_dir, "hse.gpw"),
                    xc="HSE06",
                    bands=[0, nbands])
     calc_hse.calculate()
     vxc_hse = calc_hse.get_eigenvalue_contributions()
     parprint(vxc_hse.shape)
     parprint(vxc_hse)
     eigen_hse = eigen_pbe - vxc_pbe + vxc_hse
     
     # HSE bandgap from just kpts
     bg_hse_min, *_ = bandgap(eigenvalues=eigen_hse,
                              efermi=calc.get_fermi_level(),
                              direct=False)
     bg_hse_dir, *_ = bandgap(eigenvalues=eigen_hse,
                              efermi=calc.get_fermi_level(),
                              direct=True)
     parprint("HSE: E_min \t E_dir")
     parprint("{:.3f}\t{:.3f}".format(bg_hse_min, bg_hse_dir))
     """
示例#2
0
文件: g0w0.py 项目: robwarm/gpaw-symm
 def calculate_exact_exchange(self):
     name = self.filename + '.exx.npy'
     fd = opencew(name)
     if fd is None:
         print('Reading EXX contribution from file:', name, file=self.fd)
         with open(name) as fd:
             self.exx_sin = np.load(fd)
         assert self.exx_sin.shape == self.shape, self.exx_sin.shape
         return
         
     print('Calculating EXX contribution', file=self.fd)
     exx = EXX(self.calc, kpts=self.kpts, bands=self.bands,
               txt=self.filename + '.exx.txt', timer=self.timer)
     exx.calculate()
     self.exx_sin = exx.get_eigenvalue_contributions() / Hartree
     np.save(fd, self.exx_sin)
示例#3
0
 def calculate_exact_exchange(self):
     name = self.filename + '.exx.npy'
     fd = opencew(name)
     if fd is None:
         print('Reading EXX contribution from file:', name, file=self.fd)
         with open(name) as fd:
             self.exx_sin = np.load(fd)
         assert self.exx_sin.shape == self.shape, self.exx_sin.shape
         return
         
     print('Calculating EXX contribution', file=self.fd)
     exx = EXX(self.calc, kpts=self.kpts, bands=self.bands,
               txt=self.filename + '.exx.txt', timer=self.timer)
     exx.calculate()
     self.exx_sin = exx.get_eigenvalue_contributions() / Hartree
     np.save(fd, self.exx_sin)
示例#4
0
def xc(filename, xc, ecut=None):
    """Calculate non self-consitent energy.
    
    filename: str
        Name of restart-file.
    xc: str
        Functional
    ecut: float
        Plane-wave cutoff for exact exchange.
    """
    name, ext = filename.rsplit('.', 1)
    assert ext == 'gpw'
    if xc in ['EXX', 'PBE0', 'B3LYP']:
        from gpaw.xc.exx import EXX
        exx = EXX(filename, xc, ecut=ecut, txt=name + '-exx.txt')
        exx.calculate()
        e = exx.get_total_energy()
    else:
        from gpaw import GPAW
        calc = GPAW(filename, txt=None)
        e = calc.get_potential_energy() + calc.get_xc_difference(xc)
    print(e, 'eV')
def xc(filename, xc, ecut=None):
    """Calculate non self-consitent energy.
    
    filename: str
        Name of restart-file.
    xc: str
        Functional
    ecut: float
        Plane-wave cutoff for exact exchange.
    """
    name, ext = filename.rsplit(".", 1)
    assert ext == "gpw"
    if xc in ["EXX", "PBE0", "B3LYP"]:
        from gpaw.xc.exx import EXX

        exx = EXX(filename, xc, ecut=ecut, txt=name + "-exx.txt")
        exx.calculate()
        e = exx.get_total_energy()
    else:
        from gpaw import GPAW

        calc = GPAW(filename, txt=None)
        e = calc.get_potential_energy() + calc.get_xc_difference(xc)
    print(e, "eV")
    isolated_calc = GPAW(
        mode=PW(pwcutoff),
        dtype=complex,
        kpts=(1, 1, 1),
        xc="PBE",
        txt="si_isolated_pbe.txt",
        occupations=FermiDirac(0.01, fixmagmom=True),
        spinpol=True,
        hund=True,
        convergence={"density": 1.0e-6},
        mixer=Mixer(beta=0.05, nmaxold=5, weight=50.0),
    )

    isolated_silicon.set_calculator(isolated_calc)

    e0_isolated_pbe = isolated_silicon.get_potential_energy()
    isolated_calc.write("si.pbe+exx.isolated.gpw", mode="all")

    # Now the exact exchange
    exx = EXX("si.pbe+exx.isolated.gpw", txt="si_isolated_exx.txt")
    exx.calculate()
    si_isolated_exx = exx.get_total_energy()

    s = str(L)
    s += " "
    s += str(e0_isolated_pbe)
    s += " "
    s += str(si_isolated_exx)
    s += "\n"
    myresults.write(s)
示例#7
0
                     'size': (k, k, k),
                     'gamma': True
                 },
                 xc='PBE',
                 occupations=FermiDirac(0.01),
                 txt='si.pbe+exx.pbe_output.txt',
                 parallel={'band': 1})

bulk_crystal.set_calculator(bulk_calc)
e0_bulk_pbe = bulk_crystal.get_potential_energy()

#  Write to file
bulk_calc.write('bulk.gpw', mode='all')

# Now the exact exchange
exx_bulk = EXX('bulk.gpw', txt='si.pbe+exx.exx_output.txt')
exx_bulk.calculate()
e0_bulk_exx = exx_bulk.get_total_energy()

s = str(alat)
s += ' '
s += str(k)
s += ' '
s += str(pwcutoff)
s += ' '
s += str(e0_bulk_pbe)
s += ' '
s += str(e0_bulk_exx)
s += '\n'
resultfile.write(s)
示例#8
0
N2 = molecule('N2')
N2.center(vacuum=2.0)

calc = GPAW(mode=PW(force_complex_dtype=True),
            xc='PBE',
            parallel={'domain': 1},
            eigensolver='rmm-diis')
N2.set_calculator(calc)
E_n2_pbe = N2.get_potential_energy()

calc.diagonalize_full_hamiltonian(nbands=104, scalapack=True)
calc.write('N2.gpw', mode='all')

exx = EXX('N2.gpw')
exx.calculate()
E_n2_hf = exx.get_total_energy()

rpa = RPACorrelation('N2.gpw', nfrequencies=8)
E_n2_rpa = rpa.calculate(ecut=[ecut])

N = molecule('N')
N.set_cell(N2.cell)

calc = GPAW(mode=PW(force_complex_dtype=True),
            xc='PBE',
            parallel={'domain': 1},
            eigensolver='rmm-diis')
N.set_calculator(calc)
E_n_pbe = N.get_potential_energy()
示例#9
0
    ibzk_kc = atoms.calc.get_ibz_k_points()
    n = int(atoms.calc.get_number_of_electrons()) // 2
    
    ibzk = []
    eps_kn = []
    for k_c in [(0, 0, 0), (0.5, 0.5, 0), (0.5, 0.5, 0.5)]:
        k = abs(ibzk_kc - k_c).max(1).argmin()
        ibzk.append(k)
        eps_kn.append(atoms.calc.get_eigenvalues(k)[n - 1:n + 1])
        if name == 'Ar':
            break

    deps_kn = vxc(atoms.calc, 'PBE')[0, ibzk, n - 1:n + 1]
        
    pbe0 = EXX(name + '.gpw', 'PBE0', ibzk, (n - 1, n + 1), txt=name + '.exx')
    pbe0.calculate()
    deps0_kn = pbe0.get_eigenvalue_contributions()[0]

    eps0_kn = eps_kn - deps_kn + deps0_kn

    data = {}
    for k, point in enumerate('GXL'):
        data[point] = [eps_kn[k][1] - eps_kn[0][0],
                       eps0_kn[k, 1] - eps0_kn[0, 0]]
        data[point] += bfb[name][2 + k * 4:6 + k * 4]
        if name == 'Ar':
            break
            
    c.write(atoms, name=name, data=data)
    del c[id]
示例#10
0
文件: gaps.py 项目: robwarm/gpaw-symm
    ibzk_kc = atoms.calc.get_ibz_k_points()
    n = int(atoms.calc.get_number_of_electrons()) // 2
    
    ibzk = []
    eps_kn = []
    for k_c in [(0, 0, 0), (0.5, 0.5, 0), (0.5, 0.5, 0.5)]:
        k = abs(ibzk_kc - k_c).max(1).argmin()
        ibzk.append(k)
        eps_kn.append(atoms.calc.get_eigenvalues(k)[n - 1:n + 1])
        if name == 'Ar':
            break

    deps_kn = vxc(atoms.calc, 'PBE')[0, ibzk, n - 1:n + 1]
        
    pbe0 = EXX(name, 'PBE0', ibzk, (n - 1, n + 1), txt=name + '.exx')
    pbe0.calculate()
    deps0_kn = pbe0.get_eigenvalue_contributions()[0]

    eps0_kn = eps_kn - deps_kn + deps0_kn

    data = {}
    for k, point in enumerate('GXL'):
        data[point] = [eps_kn[k][1] - eps_kn[0][0],
                       eps0_kn[k, 1] - eps0_kn[0, 0]]
        data[point] += bfb[name][2 + k * 4:6 + k * 4]
        if name == 'Ar':
            break
            
    c.write(atoms, name=name, data=data)
    del c[id]
示例#11
0
            mode = PW(pwcutoff),
            kpts={'size': (k, k, k), 'gamma': True},
            dtype=complex,
            xc='PBE',
            txt='si.pbe+exx.pbe_output.txt',
            parallel={'band':1}
            )

bulk_crystal.set_calculator(bulk_calc)
e0_bulk_pbe = bulk_crystal.get_potential_energy()

#  Write to file
bulk_calc.write('bulk.gpw',mode='all')

# Now the exact exchange
exx_bulk = EXX('bulk.gpw', txt='si.pbe+exx.exx_output.txt')
exx_bulk.calculate()
e0_bulk_exx = exx_bulk.get_total_energy()

s = str(alat)
s += ' '
s += str(k)
s += ' '
s += str(pwcutoff)
s += ' '
s += str(e0_bulk_pbe)
s += ' '
s += str(e0_bulk_exx)
s += '\n'
resultfile.write(s)
示例#12
0
def hse(base_dir="./", kdens=6.0):
    emptybands = 20
    convbands = 10
    # If pbc in z direction, use vdW for relaxation as default!
    # if atoms.pbc[-1]:           # Do not compare with np.bool_ !
    # use_vdW = True
    # else:
    # use_vdW = False

    curr_dir = os.path.dirname(os.path.abspath(__file__))
    param_file = os.path.join(curr_dir, "../parameters.json")

    gpw_file = os.path.join(base_dir, "gs.gpw")
    hse_file = os.path.join(base_dir, "hse.gpw")
    hse_nowfs_file = os.path.join(base_dir, "hse_nowfs.gpw")
    hse_eigen_file = os.path.join(base_dir, "hse_eigenvalues.npz")
    if not os.path.exists(gpw_file):
        parprint("No ground state calculation? Exit...")
        return 0
    if os.path.exists(param_file):
        params = json.load(open(param_file, "r"))
    else:
        raise FileNotFoundError("no parameter file!")

    if not os.path.exists(hse_file):
        calc = GPAW(gpw_file)  # reload the calculation
        atoms = calc.get_atoms()
        kpts = get_kpts_size(atoms, kdens)
        calc.set(nbands=-emptybands,
                 fixdensity=True,
                 kpts=kpts,
                 convergence={'bands': -convbands})
        calc.get_potential_energy()
        calc.write(hse_file, 'all')
        calc.write(hse_nowfs_file)  # no wavefunction

    mpi.world.barrier()
    time.sleep(10)  # is this needed?
    calc = GPAW(hse_file, txt=None)
    ns = calc.get_number_of_spins()
    nk = len(calc.get_ibz_k_points())
    nb = calc.get_number_of_bands()
    vxc_pbe_skn = vxc(calc, 'PBE')
    vxc_pbe_nsk = numpy.ascontiguousarray(vxc_pbe_skn.transpose(2, 0, 1))
    vxc_pbe_nsk = calc.wfs.bd.collect(vxc_pbe_nsk, broadcast=True)
    vxc_pbe_skn = vxc_pbe_nsk.transpose(1, 2, 0)[:, :, :-convbands]
    e_pbe_skn = np.zeros((ns, nk, nb))
    for s in range(ns):
        for k in range(nk):
            e_pbe_skn[s, k, :] = calc.get_eigenvalues(spin=s, kpt=k)

    e_pbe_skn = e_pbe_skn[:, :, :-convbands]
    hse_calc = EXX(hse_file, xc='HSE06', bands=[0, nb - convbands])
    hse_calc.calculate()
    vxc_hse_skn = hse_calc.get_eigenvalue_contributions()
    e_hse_skn = e_pbe_skn - vxc_pbe_skn + vxc_hse_skn
    ranks = [0]
    if mpi.world.rank in ranks:
        dct = dict(vxc_hse_skn=vxc_hse_skn,
                   e_pbe_skn=e_pbe_skn,
                   vxc_pbe_skn=vxc_pbe_skn,
                   e_hse_skn=e_hse_skn)
        with open(hse_eigen_file, 'wb') as f:
            numpy.savez(f, **dct)
    parprint("Single HSE06 finished!")