def set_grid_descriptor(self, gd):
if self.gd is not None and self.gd != gd:
raise NotImplementedError('Cannot switch grids')
if self.libvdwxc is None:
self._initialize(gd)
XCFunctional.set_grid_descriptor(self, gd)
self.semilocal_xc.set_grid_descriptor(gd)
def __init__(self, name, hybrid=None, xc=None, finegrid=False):
"""Mix standard functionals with exact exchange.
name: str
Name of hybrid functional.
hybrid: float
Fraction of exact exchange.
xc: str or XCFunctional object
Standard DFT functional with scaled down exchange.
finegrid: boolean
Use fine grid for energy functional evaluations?
"""
if name == 'EXX':
assert hybrid is None and xc is None
hybrid = 1.0
xc = XC(XCNull())
elif name == 'PBE0':
assert hybrid is None and xc is None
hybrid = 0.25
xc = XC('HYB_GGA_XC_PBEH')
elif name == 'B3LYP':
assert hybrid is None and xc is None
hybrid = 0.2
xc = XC('HYB_GGA_XC_B3LYP')
if isinstance(xc, str):
xc = XC(xc)
self.hybrid = hybrid
self.xc = xc
self.type = xc.type
self.finegrid = finegrid
XCFunctional.__init__(self, name)
def __init__(self, xcname):
self.contributions = []
self.xcs = {}
XCFunctional.__init__(self, xcname)
self.mix = None
self.mix_vt_sg = None
self.old_vt_sg = None
self.old_H_asp = {}
def __init__(self, xcname):
self.contributions = []
self.xcs = {}
XCFunctional.__init__(self, xcname, 'GLLB')
self.mix = None
self.mix_vt_sg = None
self.old_vt_sg = None
self.old_H_asp = {}
def __init__(self, name, hybrid=None, xc=None, finegrid=False,
alpha=None, skip_gamma=False, gygi=False, acdf=True,
qsym=True, txt=None, ecut=None):
"""Mix standard functionals with exact exchange.
name: str
Name of hybrid functional.
hybrid: float
Fraction of exact exchange.
xc: str or XCFunctional object
Standard DFT functional with scaled down exchange.
finegrid: boolean
Use fine grid for energy functional evaluations?
"""
if name == 'EXX':
assert hybrid is None and xc is None
hybrid = 1.0
xc = XC(XCNull())
elif name == 'PBE0':
assert hybrid is None and xc is None
hybrid = 0.25
xc = XC('HYB_GGA_XC_PBEH')
elif name == 'B3LYP':
assert hybrid is None and xc is None
hybrid = 0.2
xc = XC('HYB_GGA_XC_B3LYP')
if isinstance(xc, str):
xc = XC(xc)
self.hybrid = hybrid
self.xc = xc
self.type = xc.type
self.alpha = alpha
self.qsym = qsym
self.skip_gamma = skip_gamma
self.gygi = gygi
self.acdf = acdf
self.exx = None
self.ecut = ecut
if txt is None:
if rank == 0:
#self.txt = devnull
self.txt = sys.stdout
else:
sys.stdout = devnull
self.txt = devnull
else:
assert type(txt) is str
from ase.parallel import paropen
self.txt = paropen(txt, 'w')
XCFunctional.__init__(self, name)
def __init__(self, xc='LDA', finegrid=False, **parameters):
"""Self-Interaction Corrected Functionals (PZ-SIC).
finegrid: boolean
Use fine grid for energy functional evaluations?
"""
if isinstance(xc, str):
xc = XC(xc)
self.xc = xc
self.type = xc.type
XCFunctional.__init__(self, xc.name + '-PZ-SIC')
self.finegrid = finegrid
self.parameters = parameters
def __init__(self, xc='LDA', finegrid=False, **parameters):
"""Self-Interaction Corrected Functionals (PZ-SIC).
finegrid: boolean
Use fine grid for energy functional evaluations?
"""
if isinstance(xc, str):
xc = XC(xc)
self.xc = xc
self.type = xc.type
XCFunctional.__init__(self, xc.name + '-PZ-SIC')
self.finegrid = finegrid
self.parameters = parameters
def __init__(self, xc='LDA', finegrid=False, **parameters):
"""Self-Interaction Corrected Functionals (PZ-SIC).
finegrid: boolean
Use fine grid for energy functional evaluations?
"""
if isinstance(xc, basestring):
xc = XC(xc)
if xc.orbital_dependent:
raise ValueError('SIC does not support ' + xc.name)
self.xc = xc
XCFunctional.__init__(self, xc.name + '-PZ-SIC', xc.type)
self.finegrid = finegrid
self.parameters = parameters
def __init__(self, name, hybrid=None, xc=None, omega=None):
"""Mix standard functionals with exact exchange.
name: str
Name of hybrid functional.
hybrid: float
Fraction of exact exchange.
xc: str or XCFunctional object
Standard DFT functional with scaled down exchange.
"""
if name == 'EXX':
assert hybrid is None and xc is None
hybrid = 1.0
xc = XC(XCNull())
elif name == 'PBE0':
assert hybrid is None and xc is None
hybrid = 0.25
xc = XC('HYB_GGA_XC_PBEH')
elif name == 'B3LYP':
assert hybrid is None and xc is None
hybrid = 0.2
xc = XC('HYB_GGA_XC_B3LYP')
elif name == 'HSE03':
assert hybrid is None and xc is None and omega is None
hybrid = 0.25
omega = 0.106
xc = XC('HYB_GGA_XC_HSE03')
elif name == 'HSE06':
assert hybrid is None and xc is None and omega is None
hybrid = 0.25
omega = 0.11
xc = XC('HYB_GGA_XC_HSE06')
if isinstance(xc, str):
xc = XC(xc)
self.hybrid = float(hybrid)
self.xc = xc
self.omega = omega
self.type = xc.type
XCFunctional.__init__(self, name)
def __init__(self, name, hybrid=None, xc=None, omega=None):
"""Mix standard functionals with exact exchange.
name: str
Name of hybrid functional.
hybrid: float
Fraction of exact exchange.
xc: str or XCFunctional object
Standard DFT functional with scaled down exchange.
"""
if name == 'EXX':
assert hybrid is None and xc is None
hybrid = 1.0
xc = XC(XCNull())
elif name == 'PBE0':
assert hybrid is None and xc is None
hybrid = 0.25
xc = XC('HYB_GGA_XC_PBEH')
elif name == 'B3LYP':
assert hybrid is None and xc is None
hybrid = 0.2
xc = XC('HYB_GGA_XC_B3LYP')
elif name == 'HSE03':
assert hybrid is None and xc is None and omega is None
hybrid = 0.25
omega = 0.106
xc = XC('HYB_GGA_XC_HSE03')
elif name == 'HSE06':
assert hybrid is None and xc is None and omega is None
hybrid = 0.25
omega = 0.11
xc = XC('HYB_GGA_XC_HSE06')
if isinstance(xc, str):
xc = XC(xc)
self.hybrid = float(hybrid)
self.xc = xc
self.omega = omega
self.type = xc.type
XCFunctional.__init__(self, name)
def __init__(self, kernel, stencil=2):
"""Meta GGA functional."""
XCFunctional.__init__(self, kernel.name, kernel.type)
self.kernel = kernel
self.stencil = stencil
def __init__(self,
name,
hybrid=None,
xc=None,
finegrid=False,
alpha=None,
skip_gamma=False,
gygi=False,
acdf=True,
qsym=True,
txt=None,
ecut=None):
"""Mix standard functionals with exact exchange.
name: str
Name of hybrid functional.
hybrid: float
Fraction of exact exchange.
xc: str or XCFunctional object
Standard DFT functional with scaled down exchange.
finegrid: boolean
Use fine grid for energy functional evaluations?
"""
if name == 'EXX':
assert hybrid is None and xc is None
hybrid = 1.0
xc = XC(XCNull())
elif name == 'PBE0':
assert hybrid is None and xc is None
hybrid = 0.25
xc = XC('HYB_GGA_XC_PBEH')
elif name == 'B3LYP':
assert hybrid is None and xc is None
hybrid = 0.2
xc = XC('HYB_GGA_XC_B3LYP')
if isinstance(xc, str):
xc = XC(xc)
self.hybrid = hybrid
self.xc = xc
self.type = xc.type
self.alpha = alpha
self.qsym = qsym
self.skip_gamma = skip_gamma
self.gygi = gygi
self.acdf = acdf
self.exx = None
self.ecut = ecut
if txt is None:
if rank == 0:
#self.txt = devnull
self.txt = sys.stdout
else:
sys.stdout = devnull
self.txt = devnull
else:
assert type(txt) is str
from ase.parallel import paropen
self.txt = paropen(txt, 'w')
XCFunctional.__init__(self, name)
def __init__(self, kernel):
"""Meta GGA functional."""
XCFunctional.__init__(self, kernel.name, kernel.type)
self.kernel = kernel
def __init__(self, kernel, stencil=2):
XCFunctional.__init__(self, kernel.name, kernel.type)
self.kernel = kernel
self.stencil_range = stencil
def set_grid_descriptor(self, gd):
XCFunctional.set_grid_descriptor(self, gd)
self.semilocal_xc.set_grid_descriptor(gd)
def __init__(self,
semilocal_xc,
name,
mode='auto',
pfft_grid=None,
libvdwxc_name=None,
setup_name='revPBE',
vdwcoef=1.0,
accept_partial_decomposition=False):
"""Initialize VDWXC object (further initialization required).
mode can be 'auto', 'serial', 'mpi', or 'pfft'.
* 'serial' uses FFTW and only works with serial decompositions.
* 'mpi' uses FFTW-MPI with communicator of the grid
descriptor, parallelizing along the x axis.
* 'pfft' uses PFFT and works with any decomposition,
parallelizing along two directions for best scalability.
* 'auto' uses PFFT if pfft_grid is given, else FFTW-MPI if the
calculation uses more than one core, else serial FFTW.
pfft_grid is the 2D CPU grid used by PFFT and can be a tuple
(nproc1, nproc2) that multiplies to total communicator size,
or None. It is an error to specify pfft_grid unless using
PFFT. If left unspecified, a hopefully reasonable automatic
choice will be made.
"""
# XXX We should probably not initialize with the same data as the
# semilocal XC kernel.
XCFunctional.__init__(self, semilocal_xc.kernel.name,
semilocal_xc.kernel.type)
# Really, 'type' should be something along the lines of vdw-df.
self.semilocal_xc = semilocal_xc
# We set these in the initialize later (ugly).
self.libvdwxc = None
self.distribution = None
self.redist_wrapper = None
self.timer = nulltimer
self.setup_name = setup_name
# These parameters are simply stored for later forwarding
self.name = name
if libvdwxc_name is None:
libvdwxc_name = name
self._libvdwxc_name = libvdwxc_name
self._mode = mode
self._pfft_grid = pfft_grid
self._vdwcoef = vdwcoef
self.accept_partial_decomposition = accept_partial_decomposition
self._nspins = 1
self.last_nonlocal_energy = None
self.last_semilocal_energy = None
# XXXXXXXXXXXXXXXXX
self.calculate_paw_correction = semilocal_xc.calculate_paw_correction
#self.stress_tensor_contribution = semilocal_xc.stress_tensor_contribution
self.calculate_spherical = semilocal_xc.calculate_spherical
self.apply_orbital_dependent_hamiltonian = semilocal_xc.apply_orbital_dependent_hamiltonian
self.add_forces = semilocal_xc.add_forces
self.get_kinetic_energy_correction = semilocal_xc.get_kinetic_energy_correction
self.rotate = semilocal_xc.rotate
def __init__(self, kernel):
self.kernel = kernel
XCFunctional.__init__(self, kernel.name)
self.type = kernel.type
def __init__(self, xc):
XCFunctional.__init__(self, xc.name)
self.xc = xc
self.type = xc.type
def __init__(self, xcname):
self.contributions = []
self.xcs = {}
XCFunctional.__init__(self, xcname)
def __init__(self, xcname):
self.contributions = []
self.xcs = {}
XCFunctional.__init__(self, xcname)
def __init__(self, kernel):
self.kernel = kernel
XCFunctional.__init__(self, kernel.name, kernel.type)
def set_grid_descriptor(self, gd):
self.grad_v = get_gradient_ops(gd, self.stencil)
XCFunctional.set_grid_descriptor(self, gd)
def __init__(self, name, stencil=2, hybrid=None, xc=None, omega=None):
"""Mix standard functionals with exact exchange.
name: str
Name of hybrid functional.
hybrid: float
Fraction of exact exchange.
xc: str or XCFunctional object
Standard DFT functional with scaled down exchange.
"""
rsf_functionals = { # Parameters can also be taken from libxc
'CAMY-BLYP': { # Akinaga, Ten-no CPL 462 (2008) 348-351
'alpha': 0.2,
'beta': 0.8,
'omega': 0.44,
'cam': True,
'rsf': 'Yukawa',
'xc': 'HYB_GGA_XC_CAMY_BLYP'
},
'CAMY-B3LYP': { # Seth, Ziegler JCTC 8 (2012) 901-907
'alpha': 0.19,
'beta': 0.46,
'omega': 0.34,
'cam': True,
'rsf': 'Yukawa',
'xc': 'HYB_GGA_XC_CAMY_B3LYP'
},
'LCY-BLYP': { # Seth, Ziegler JCTC 8 (2012) 901-907
'alpha': 0.0,
'beta': 1.0,
'omega': 0.75,
'cam': False,
'rsf': 'Yukawa',
'xc': 'HYB_GGA_XC_LCY_BLYP'
},
'LCY-PBE': { # Seth, Ziegler JCTC 8 (2012) 901-907
'alpha': 0.0,
'beta': 1.0,
'omega': 0.75,
'cam': False,
'rsf': 'Yukawa',
'xc': 'HYB_GGA_XC_LCY_PBE'
}
}
self.omega = None
self.cam_alpha = None
self.cam_beta = None
self.is_cam = False
self.rsf = None
def _xc(name):
return {'name': name, 'stencil': stencil}
if name == 'EXX':
hybrid = 1.0
xc = XC(XCNull())
elif name == 'PBE0':
hybrid = 0.25
xc = XC(_xc('HYB_GGA_XC_PBEH'))
elif name == 'B3LYP':
hybrid = 0.2
xc = XC(_xc('HYB_GGA_XC_B3LYP'))
elif name == 'HSE03':
hybrid = 0.25
omega = 0.106
xc = XC(_xc('HYB_GGA_XC_HSE03'))
elif name == 'HSE06':
hybrid = 0.25
omega = 0.11
xc = XC(_xc('HYB_GGA_XC_HSE06'))
elif name in rsf_functionals:
rsf_functional = rsf_functionals[name]
self.cam_alpha = rsf_functional['alpha']
self.cam_beta = rsf_functional['beta']
self.omega = rsf_functional['omega']
self.is_cam = rsf_functional['cam']
self.rsf = rsf_functional['rsf']
xc = XC(rsf_functional['xc'])
hybrid = self.cam_alpha + self.cam_beta
if isinstance(xc, (basestring, dict)):
xc = XC(xc)
self.hybrid = float(hybrid)
self.xc = xc
if omega is not None:
omega = float(omega)
if self.omega is not None and self.omega != omega:
self.xc.kernel.set_omega(omega)
# Needed to tune omega for RSF
self.omega = omega
XCFunctional.__init__(self, name, xc.type)
def __init__(self, xc):
XCFunctional.__init__(self, xc.name)
self.xc = xc
self.type = xc.type
