def add_ghost_link(subsys_mols, sub_settings):
"""Adds linking ghost atoms to the subsystem mol objects.
Parameters
----------
subsys_mols : list
A list of mol objects for the different subsystems.
sub_settings : list
A list of subsystem settings
"""
max_dist = 3.8
ghost_basis = '3-21g'
#First get array of interatom distances
coord_array = np.asarray(np.vstack([x.atom_coords() for x in subsys_mols]))
inter_dist = gto.inter_distance(None, coords=coord_array)
close_indices = np.argwhere(inter_dist <= max_dist)
#Iterate through all close indices and add link atoms to the sub on one conditional line.
lowest_index = 0
for i, subsystem in enumerate(sub_settings):
num_atoms = len(subsys_mols[i].atom)
high_index = lowest_index + num_atoms
if subsystem.addlinkbasis:
ghost_mol = gto.M()
ghost_mol.atom = []
ghost_mol.basis = {}
for index in close_indices:
if ((index[0] >= lowest_index and index[0] < high_index) and
(index[1] < lowest_index or index[1] >= high_index)):
atm1_coord = coord_array[index[0]]
atm2_coord = coord_array[index[1]]
if subsystem.basis:
new_atom, new_basis = helpers.gen_link_basis(
atm1_coord, atm2_coord, subsystem.basis)
else:
new_atom, new_basis = helpers.gen_link_basis(
atm1_coord, atm2_coord, ghost_basis)
ghost_mol.atom.append(new_atom)
ghost_mol.basis.update(new_basis)
ghost_mol.build(unit='bohr')
subsys_mols[i] = gto.conc_mol(subsys_mols[i], ghost_mol)
lowest_index = high_index
def _e_nuc(mol: gto.Mole, mm_mol: Union[None, gto.Mole]) -> np.ndarray:
"""
this function returns the nuclear repulsion energy
"""
# coordinates and charges of nuclei
coords = mol.atom_coords()
charges = mol.atom_charges()
# internuclear distances (with self-repulsion removed)
dist = gto.inter_distance(mol)
dist[np.diag_indices_from(dist)] = 1e200
e_nuc = contract('i,ij,j->i', charges, 1. / dist, charges) * .5
# possible interaction with mm sites
if mm_mol is not None:
mm_coords = mm_mol.atom_coords()
mm_charges = mm_mol.atom_charges()
for j in range(mol.natm):
q2, r2 = charges[j], coords[j]
r = lib.norm(r2 - mm_coords, axis=1)
e_nuc[j] += q2 * np.sum(mm_charges / r)
return e_nuc
def __remove_overlap_ghost(mol):
"""Removes overlapping ghost atoms between mol objects
Parameters
__________
mol : Mole object
The mole object to remove ghost atoms from. Removes them in-place.
Returns
-------
Mole object
Mole object with overlapping ghost atoms removed
"""
int_dist = gto.inter_distance(mol)
same_coords = np.argwhere(int_dist == 0.0)
remove_list = []
while len(same_coords) > 0:
curr_coord = same_coords[-1]
if curr_coord[0] == curr_coord[1]:
same_coords = same_coords[:-1]
else:
atom1 = mol.atom_symbol(curr_coord[0]).lower()
atom2 = mol.atom_symbol(curr_coord[1]).lower()
assert ("ghost" in atom1 or "ghost" in atom2),\
f"{atom1.capitalize()} and {atom2.capitalize()} are overlapping!"
if "ghost" in atom2:
remove_list.append(curr_coord[1])
else:
remove_list.append(curr_coord[0])
same_coords = same_coords[:-1]
inverse_coords = (curr_coord[1], curr_coord[0])
inverse_index = np.argwhere(
(same_coords == inverse_coords).all(axis=1))
same_coords = np.delete(same_coords, inverse_index, axis=0)
for remove_index in sorted(remove_list, reverse=True):
mol.atom.pop(remove_index)
mol.build()
return mol
def grids_response_cc(grids):
mol = grids.mol
atom_grids_tab = grids.gen_atomic_grids(mol, grids.atom_grid,
grids.radi_method, grids.level,
grids.prune)
atm_coords = numpy.asarray(mol.atom_coords(), order='C')
atm_dist = gto.inter_distance(mol, atm_coords)
def _radii_adjust(mol, atomic_radii):
charges = mol.atom_charges()
if grids.radii_adjust == radi.treutler_atomic_radii_adjust:
rad = numpy.sqrt(atomic_radii[charges]) + 1e-200
elif grids.radii_adjust == radi.becke_atomic_radii_adjust:
rad = atomic_radii[charges] + 1e-200
else:
fadjust = lambda i, j, g: g
gadjust = lambda *args: 1
return fadjust, gadjust
rr = rad.reshape(-1, 1) * (1. / rad)
a = .25 * (rr.T - rr)
a[a < -.5] = -.5
a[a > 0.5] = 0.5
def fadjust(i, j, g):
return g + a[i, j] * (1 - g**2)
#: d[g + a[i,j]*(1-g**2)] /dg = 1 - 2*a[i,j]*g
def gadjust(i, j, g):
return 1 - 2 * a[i, j] * g
return fadjust, gadjust
fadjust, gadjust = _radii_adjust(mol, grids.atomic_radii)
def gen_grid_partition(coords, atom_id):
ngrids = coords.shape[0]
grid_dist = []
grid_norm_vec = []
for ia in range(mol.natm):
v = (atm_coords[ia] - coords).T
normv = numpy.linalg.norm(v, axis=0) + 1e-200
v /= normv
grid_dist.append(normv)
grid_norm_vec.append(v)
def get_du(ia, ib): # JCP 98, 5612 (1993); (B10)
uab = atm_coords[ia] - atm_coords[ib]
duab = 1. / atm_dist[ia, ib] * grid_norm_vec[ia]
duab -= uab[:, None] / atm_dist[ia, ib]**3 * (grid_dist[ia] -
grid_dist[ib])
return duab
pbecke = numpy.ones((mol.natm, ngrids))
dpbecke = numpy.zeros((mol.natm, mol.natm, 3, ngrids))
for ia in range(mol.natm):
for ib in range(ia):
g = 1 / atm_dist[ia, ib] * (grid_dist[ia] - grid_dist[ib])
p0 = fadjust(ia, ib, g)
p1 = (3 - p0**2) * p0 * .5
p2 = (3 - p1**2) * p1 * .5
p3 = (3 - p2**2) * p2 * .5
t_uab = 27. / 16 * (1 - p2**2) * (1 - p1**2) * (
1 - p0**2) * gadjust(ia, ib, g)
s_uab = .5 * (1 - p3 + 1e-200)
s_uba = .5 * (1 + p3 + 1e-200)
pbecke[ia] *= s_uab
pbecke[ib] *= s_uba
pt_uab = -t_uab / s_uab
pt_uba = t_uab / s_uba
# * When grid is on atom ia/ib, ua/ub == 0, d_uba/d_uab may have huge error
# How to remove this error?
duab = get_du(ia, ib)
duba = get_du(ib, ia)
if ia == atom_id:
dpbecke[ia, ia] += pt_uab * duba
dpbecke[ia, ib] += pt_uba * duba
else:
dpbecke[ia, ia] += pt_uab * duab
dpbecke[ia, ib] += pt_uba * duab
if ib == atom_id:
dpbecke[ib, ib] -= pt_uba * duab
dpbecke[ib, ia] -= pt_uab * duab
else:
dpbecke[ib, ib] -= pt_uba * duba
dpbecke[ib, ia] -= pt_uab * duba
# * JCP 98, 5612 (1993); (B8) (B10) miss many terms
if ia != atom_id and ib != atom_id:
ua_ub = grid_norm_vec[ia] - grid_norm_vec[ib]
ua_ub /= atm_dist[ia, ib]
dpbecke[atom_id, ia] -= pt_uab * ua_ub
dpbecke[atom_id, ib] -= pt_uba * ua_ub
for ia in range(mol.natm):
dpbecke[:, ia] *= pbecke[ia]
return pbecke, dpbecke
natm = mol.natm
for ia in range(natm):
coords, vol = atom_grids_tab[mol.atom_symbol(ia)]
coords = coords + atm_coords[ia]
pbecke, dpbecke = gen_grid_partition(coords, ia)
z = 1. / pbecke.sum(axis=0)
w1 = dpbecke[:, ia] * z
w1 -= pbecke[ia] * z**2 * dpbecke.sum(axis=1)
w1 *= vol
w0 = vol * pbecke[ia] * z
yield coords, w0, w1
def gen_partition(mol, atom_grids_tab,
radii_adjust=None, atomic_radii=radi.BRAGG_RADII,
becke_scheme=original_becke):
'''Generate the mesh grid coordinates and weights for DFT numerical integration.
We can change radii_adjust, becke_scheme functions to generate different meshgrid.
Returns:
grid_coord and grid_weight arrays. grid_coord array has shape (N,3);
weight 1D array has N elements.
'''
if callable(radii_adjust) and atomic_radii is not None:
f_radii_adjust = radii_adjust(mol, atomic_radii)
else:
f_radii_adjust = None
atm_coords = numpy.asarray(mol.atom_coords() , order='C')
atm_dist = gto.inter_distance(mol)
if (becke_scheme is original_becke and
(radii_adjust is radi.treutler_atomic_radii_adjust or
radii_adjust is radi.becke_atomic_radii_adjust or
f_radii_adjust is None)):
if f_radii_adjust is None:
p_radii_table = lib.c_null_ptr()
else:
f_radii_table = numpy.asarray([f_radii_adjust(i, j, 0)
for i in range(mol.natm)
for j in range(mol.natm)])
p_radii_table = f_radii_table.ctypes.data_as(ctypes.c_void_p)
def gen_grid_partition(coords):
coords = numpy.asarray(coords, order='F')
ngrids = coords.shape[0]
pbecke = numpy.empty((mol.natm,ngrids))
libdft.VXCgen_grid(pbecke.ctypes.data_as(ctypes.c_void_p),
coords.ctypes.data_as(ctypes.c_void_p),
atm_coords.ctypes.data_as(ctypes.c_void_p),
p_radii_table,
ctypes.c_int(mol.natm), ctypes.c_int(ngrids))
return pbecke
else:
def gen_grid_partition(coords):
ngrids = coords.shape[0]
grid_dist = numpy.empty((mol.natm,ngrids))
for ia in range(mol.natm):
dc = coords - atm_coords[ia]
grid_dist[ia] = numpy.sqrt(numpy.einsum('ij,ij->i',dc,dc))
pbecke = numpy.ones((mol.natm,ngrids))
for i in range(mol.natm):
for j in range(i):
g = 1/atm_dist[i,j] * (grid_dist[i]-grid_dist[j])
if f_radii_adjust is not None:
g = f_radii_adjust(i, j, g)
g = becke_scheme(g)
pbecke[i] *= .5 * (1-g)
pbecke[j] *= .5 * (1+g)
return pbecke
coords_all = []
weights_all = []
for ia in range(mol.natm):
coords, vol = atom_grids_tab[mol.atom_symbol(ia)]
coords = coords + atm_coords[ia]
pbecke = gen_grid_partition(coords)
weights = vol * pbecke[ia] * (1./pbecke.sum(axis=0))
coords_all.append(coords)
weights_all.append(weights)
return numpy.vstack(coords_all), numpy.hstack(weights_all)
def gen_partition(mol, atom_grids_tab,
radii_adjust=None, atomic_radii=radi.BRAGG_RADII,
becke_scheme=original_becke):
'''Generate the mesh grid coordinates and weights for DFT numerical integration.
We can change radii_adjust, becke_scheme functions to generate different meshgrid.
Returns:
grid_coord and grid_weight arrays. grid_coord array has shape (N,3);
weight 1D array has N elements.
'''
if callable(radii_adjust) and atomic_radii is not None:
f_radii_adjust = radii_adjust(mol, atomic_radii)
else:
f_radii_adjust = None
atm_coords = numpy.asarray(mol.atom_coords() , order='C')
atm_dist = gto.inter_distance(mol)
if (becke_scheme is original_becke and
(radii_adjust is radi.treutler_atomic_radii_adjust or
radii_adjust is radi.becke_atomic_radii_adjust or
f_radii_adjust is None)):
if f_radii_adjust is None:
p_radii_table = lib.c_null_ptr()
else:
f_radii_table = numpy.asarray([f_radii_adjust(i, j, 0)
for i in range(mol.natm)
for j in range(mol.natm)])
p_radii_table = f_radii_table.ctypes.data_as(ctypes.c_void_p)
def gen_grid_partition(coords):
coords = numpy.asarray(coords, order='F')
ngrids = coords.shape[0]
pbecke = numpy.empty((mol.natm,ngrids))
libdft.VXCgen_grid(pbecke.ctypes.data_as(ctypes.c_void_p),
coords.ctypes.data_as(ctypes.c_void_p),
atm_coords.ctypes.data_as(ctypes.c_void_p),
p_radii_table,
ctypes.c_int(mol.natm), ctypes.c_int(ngrids))
return pbecke
else:
def gen_grid_partition(coords):
ngrids = coords.shape[0]
grid_dist = numpy.empty((mol.natm,ngrids))
for ia in range(mol.natm):
dc = coords - atm_coords[ia]
grid_dist[ia] = numpy.sqrt(numpy.einsum('ij,ij->i',dc,dc))
pbecke = numpy.ones((mol.natm,ngrids))
for i in range(mol.natm):
for j in range(i):
g = 1/atm_dist[i,j] * (grid_dist[i]-grid_dist[j])
if f_radii_adjust is not None:
g = f_radii_adjust(i, j, g)
g = becke_scheme(g)
pbecke[i] *= .5 * (1-g)
pbecke[j] *= .5 * (1+g)
return pbecke
coords_all = []
weights_all = []
for ia in range(mol.natm):
coords, vol = atom_grids_tab[mol.atom_symbol(ia)]
coords = coords + atm_coords[ia]
pbecke = gen_grid_partition(coords)
weights = vol * pbecke[ia] * (1./pbecke.sum(axis=0))
coords_all.append(coords)
weights_all.append(weights)
return numpy.vstack(coords_all), numpy.hstack(weights_all)
def grids_response_cc(grids):
mol = grids.mol
atom_grids_tab = grids.gen_atomic_grids(mol, grids.atom_grid,
grids.radi_method,
grids.level, grids.prune)
atm_coords = numpy.asarray(mol.atom_coords() , order='C')
atm_dist = gto.inter_distance(mol, atm_coords)
def _radii_adjust(mol, atomic_radii):
charges = mol.atom_charges()
if grids.radii_adjust == radi.treutler_atomic_radii_adjust:
rad = numpy.sqrt(atomic_radii[charges]) + 1e-200
elif grids.radii_adjust == radi.becke_atomic_radii_adjust:
rad = atomic_radii[charges] + 1e-200
else:
fadjust = lambda i, j, g: g
gadjust = lambda *args: 1
return fadjust, gadjust
rr = rad.reshape(-1,1) * (1./rad)
a = .25 * (rr.T - rr)
a[a<-.5] = -.5
a[a>0.5] = 0.5
def fadjust(i, j, g):
return g + a[i,j]*(1-g**2)
#: d[g + a[i,j]*(1-g**2)] /dg = 1 - 2*a[i,j]*g
def gadjust(i, j, g):
return 1 - 2*a[i,j]*g
return fadjust, gadjust
fadjust, gadjust = _radii_adjust(mol, grids.atomic_radii)
def gen_grid_partition(coords, atom_id):
ngrids = coords.shape[0]
grid_dist = []
grid_norm_vec = []
for ia in range(mol.natm):
v = (atm_coords[ia] - coords).T
normv = numpy.linalg.norm(v,axis=0) + 1e-200
v /= normv
grid_dist.append(normv)
grid_norm_vec.append(v)
def get_du(ia, ib): # JCP, 98, 5612 (B10)
uab = atm_coords[ia] - atm_coords[ib]
duab = 1./atm_dist[ia,ib] * grid_norm_vec[ia]
duab-= uab[:,None]/atm_dist[ia,ib]**3 * (grid_dist[ia]-grid_dist[ib])
return duab
pbecke = numpy.ones((mol.natm,ngrids))
dpbecke = numpy.zeros((mol.natm,mol.natm,3,ngrids))
for ia in range(mol.natm):
for ib in range(ia):
g = 1/atm_dist[ia,ib] * (grid_dist[ia]-grid_dist[ib])
p0 = fadjust(ia, ib, g)
p1 = (3 - p0**2) * p0 * .5
p2 = (3 - p1**2) * p1 * .5
p3 = (3 - p2**2) * p2 * .5
t_uab = 27./16 * (1-p2**2) * (1-p1**2) * (1-p0**2) * gadjust(ia, ib, g)
s_uab = .5 * (1 - p3 + 1e-200)
s_uba = .5 * (1 + p3 + 1e-200)
pbecke[ia] *= s_uab
pbecke[ib] *= s_uba
pt_uab =-t_uab / s_uab
pt_uba = t_uab / s_uba
# * When grid is on atom ia/ib, ua/ub == 0, d_uba/d_uab may have huge error
# How to remove this error?
duab = get_du(ia, ib)
duba = get_du(ib, ia)
if ia == atom_id:
dpbecke[ia,ia] += pt_uab * duba
dpbecke[ia,ib] += pt_uba * duba
else:
dpbecke[ia,ia] += pt_uab * duab
dpbecke[ia,ib] += pt_uba * duab
if ib == atom_id:
dpbecke[ib,ib] -= pt_uba * duab
dpbecke[ib,ia] -= pt_uab * duab
else:
dpbecke[ib,ib] -= pt_uba * duba
dpbecke[ib,ia] -= pt_uab * duba
# * JCP, 98, 5612 (B8) (B10) miss many terms
if ia != atom_id and ib != atom_id:
ua_ub = grid_norm_vec[ia] - grid_norm_vec[ib]
ua_ub /= atm_dist[ia,ib]
dpbecke[atom_id,ia] -= pt_uab * ua_ub
dpbecke[atom_id,ib] -= pt_uba * ua_ub
for ia in range(mol.natm):
dpbecke[:,ia] *= pbecke[ia]
return pbecke, dpbecke
natm = mol.natm
for ia in range(natm):
coords, vol = atom_grids_tab[mol.atom_symbol(ia)]
coords = coords + atm_coords[ia]
pbecke, dpbecke = gen_grid_partition(coords, ia)
z = 1./pbecke.sum(axis=0)
w1 = dpbecke[:,ia] * z
w1 -= pbecke[ia] * z**2 * dpbecke.sum(axis=1)
w1 *= vol
w0 = vol * pbecke[ia] * z
yield coords, w0, w1