def interpolate_weight(calc, weight, h=0.05, n=2):
'''interpolates cdft weight function,
gd is the fine grid '''
gd = calc.density.finegd
weight = gd.collect(weight, broadcast=True)
weight = gd.zero_pad(weight)
w = np.zeros_like(weight)
gd1 = GridDescriptor(gd.N_c, gd.cell_cv, comm=serial_comm)
gd1.distribute(weight, w)
N_c = h2gpts(h / Bohr, gd.cell_cv)
N_c = np.array([get_efficient_fft_size(N, n) for N in N_c])
gd2 = GridDescriptor(N_c, gd.cell_cv, comm=serial_comm)
interpolator = Interpolator(gd1, gd2)
W = interpolator.interpolate(w)
return W
def playground():
np.set_printoptions(linewidth=176)
#N_c = [4, 7, 9]
N_c = [4, 4, 2]
pbc_c = (1, 1, 1)
# 210
distribute_dir = 1
reduce_dir = 0
parsize_c = (2, 2, 2)
parsize2_c = list(parsize_c)
parsize2_c[reduce_dir] = 1
parsize2_c[distribute_dir] *= parsize_c[reduce_dir]
assert np.prod(parsize2_c) == np.prod(parsize_c)
gd = GridDescriptor(N_c=N_c,
pbc_c=pbc_c,
cell_cv=0.2 * np.array(N_c),
parsize_c=parsize_c)
gd2 = get_compatible_grid_descriptor(gd, distribute_dir, reduce_dir)
src = gd.zeros(dtype=complex)
src[:] = gd.comm.rank
src_global = gd.collect(src)
if gd.comm.rank == 0:
ind = np.indices(src_global.shape)
src_global += 1j * (ind[0] / 10. + ind[1] / 100. + ind[2] / 1000.)
#src_global[1] += 0.5j
print('GLOBAL ARRAY', src_global.shape)
print(src_global.squeeze())
gd.distribute(src_global, src)
goal = gd2.zeros(dtype=float)
goal[:] = gd.comm.rank # get_members()[gd2.comm.rank]
goal_global = gd2.collect(goal)
if gd.comm.rank == 0:
print('GOAL GLOBAL')
print(goal_global.squeeze())
gd.comm.barrier()
#return
recvbuf = redistribute(gd,
gd2,
src,
distribute_dir,
reduce_dir,
operation='forth')
recvbuf_master = gd2.collect(recvbuf)
if gd2.comm.rank == 0:
print('RECV')
print(recvbuf_master)
err = src_global - recvbuf_master
print('MAXERR', np.abs(err).max())
hopefully_orig = redistribute(gd,
gd2,
recvbuf,
distribute_dir,
reduce_dir,
operation='back')
tmp = gd.collect(hopefully_orig)
if gd.comm.rank == 0:
print('FINALLY')
print(tmp)
err2 = src_global - tmp
print('MAXERR', np.abs(err2).max())
from gpaw.xc.libvdwxc import vdw_df, vdw_df2, vdw_df_cx, \
vdw_optPBE, vdw_optB88, vdw_C09, vdw_beef, \
libvdwxc_has_mpi, libvdwxc_has_pfft
# This test verifies that the results returned by the van der Waals
# functionals implemented in libvdwxc do not change.
N_c = np.array([23, 10, 6])
gd = GridDescriptor(N_c, N_c * 0.2, pbc_c=(1, 0, 1))
n_sg = gd.zeros(1)
nG_sg = gd.collect(n_sg)
if gd.comm.rank == 0:
gen = np.random.RandomState(0)
nG_sg[:] = gen.rand(*nG_sg.shape)
gd.distribute(nG_sg, n_sg)
for mode in ['serial', 'mpi', 'pfft']:
if mode == 'serial' and gd.comm.size > 1:
continue
if mode == 'mpi' and not libvdwxc_has_mpi():
continue
if mode == 'pfft' and not libvdwxc_has_pfft():
continue
def test(vdwxcclass, Eref=np.nan, nvref=np.nan):
xc = vdwxcclass(mode=mode)
xc._initialize(gd)
if gd.comm.rank == 0:
print(xc.libvdwxc.tostring())
v_sg = gd.zeros(1)
