def get_combined_data(self, qmdata=None, cldata=None, spacing=None):
if qmdata is None:
qmdata = self.density.rhot_g
if cldata is None:
cldata = self.classical_material.charge_density
if spacing is None:
spacing = self.cl.gd.h_cv[0, 0]
spacing_au = spacing / Bohr # from Angstroms to a.u.
# Collect data from different processes
cln = self.cl.gd.collect(cldata)
qmn = self.qm.gd.collect(qmdata)
clgd = GridDescriptor(self.cl.gd.N_c,
self.cl.cell,
False,
serial_comm,
None)
if world.rank == 0:
cln *= self.classical_material.sign
# refine classical part
while clgd.h_cv[0, 0] > spacing_au * 1.50: # 45:
cln = Transformer(clgd, clgd.refine()).apply(cln)
clgd = clgd.refine()
# refine quantum part
qmgd = GridDescriptor(self.qm.gd.N_c,
self.qm.cell,
False,
serial_comm,
None)
while qmgd.h_cv[0, 0] < clgd.h_cv[0, 0] * 0.95:
qmn = Transformer(qmgd, qmgd.coarsen()).apply(qmn)
qmgd = qmgd.coarsen()
assert np.all(qmgd.h_cv == clgd.h_cv), " Spacings %.8f (qm) and %.8f (cl) Angstroms" % (qmgd.h_cv[0][0] * Bohr, clgd.h_cv[0][0] * Bohr)
# now find the corners
r_gv_cl = clgd.get_grid_point_coordinates().transpose((1, 2, 3, 0))
cind = self.qm.corner1 / np.diag(clgd.h_cv) - 1
n = qmn.shape
# print 'Corner points: ', self.qm.corner1*Bohr, ' - ', self.qm.corner2*Bohr
# print 'Calculated points: ', r_gv_cl[tuple(cind)]*Bohr, ' - ', r_gv_cl[tuple(cind+n+1)]*Bohr
cln[cind[0] + 1:cind[0] + n[0] + 1,
cind[1] + 1:cind[1] + n[1] + 1,
cind[2] + 1:cind[2] + n[2] + 1] += qmn
world.barrier()
return cln, clgd
def get_combined_data(self, qmdata=None, cldata=None, spacing=None):
if qmdata is None:
qmdata = self.density.rhot_g
if cldata is None:
cldata = self.classical_material.charge_density
if spacing is None:
spacing = self.cl.gd.h_cv[0, 0]
spacing_au = spacing / Bohr # from Angstroms to a.u.
# Collect data from different processes
cln = self.cl.gd.collect(cldata)
qmn = self.qm.gd.collect(qmdata)
clgd = GridDescriptor(self.cl.gd.N_c, self.cl.cell, False, serial_comm,
None)
if world.rank == 0:
cln *= self.classical_material.sign
# refine classical part
while clgd.h_cv[0, 0] > spacing_au * 1.50: # 45:
cln = Transformer(clgd, clgd.refine()).apply(cln)
clgd = clgd.refine()
# refine quantum part
qmgd = GridDescriptor(self.qm.gd.N_c, self.qm.cell, False,
serial_comm, None)
while qmgd.h_cv[0, 0] < clgd.h_cv[0, 0] * 0.95:
qmn = Transformer(qmgd, qmgd.coarsen()).apply(qmn)
qmgd = qmgd.coarsen()
assert np.all(qmgd.h_cv == clgd.h_cv
), " Spacings %.8f (qm) and %.8f (cl) Angstroms" % (
qmgd.h_cv[0][0] * Bohr, clgd.h_cv[0][0] * Bohr)
# now find the corners
r_gv_cl = clgd.get_grid_point_coordinates().transpose((1, 2, 3, 0))
cind = self.qm.corner1 / np.diag(clgd.h_cv) - 1
n = qmn.shape
# print 'Corner points: ', self.qm.corner1*Bohr, ' - ', self.qm.corner2*Bohr
# print 'Calculated points: ', r_gv_cl[tuple(cind)]*Bohr, ' - ', r_gv_cl[tuple(cind+n+1)]*Bohr
cln[cind[0] + 1:cind[0] + n[0] + 1, cind[1] + 1:cind[1] + n[1] + 1,
cind[2] + 1:cind[2] + n[2] + 1] += qmn
world.barrier()
return cln, clgd
def go(comm, ngpts, repeat, narrays, out, prec):
N_c = np.array((ngpts, ngpts, ngpts))
a = 10.0
gd = GridDescriptor(N_c, (a, a, a), comm=comm))
gdcoarse = gd.coarsen()
gdfine = gd.refine()
kin1 = Laplace(gd, -0.5, 1).apply
laplace = Laplace(gd, -0.5, 2)
kin2 = laplace.apply
restrict = Transformer(gd, gdcoarse, 1).apply
interpolate = Transformer(gd, gdfine, 1).apply
precondition = Preconditioner(gd, laplace, np_float)
a1 = gd.empty(narrays)
a1[:] = 1.0
a2 = gd.empty(narrays)
c = gdcoarse.empty(narrays)
f = gdfine.empty(narrays)
T = [0, 0, 0, 0, 0]
for i in range(repeat):
comm.barrier()
kin1(a1, a2)
comm.barrier()
t0a = time()
kin1(a1, a2)
t0b = time()
comm.barrier()
t1a = time()
kin2(a1, a2)
t1b = time()
comm.barrier()
t2a = time()
for A, C in zip(a1,c):
restrict(A, C)
t2b = time()
comm.barrier()
t3a = time()
for A, F in zip(a1,f):
interpolate(A, F)
t3b = time()
comm.barrier()
if prec:
t4a = time()
for A in a1:
precondition(A, None, None, None)
t4b = time()
comm.barrier()
T[0] += t0b - t0a
T[1] += t1b - t1a
T[2] += t2b - t2a
T[3] += t3b - t3a
if prec:
T[4] += t4b - t4a
if mpi.rank == 0:
out.write(' %2d %2d %2d' % tuple(gd.parsize_c))
out.write(' %12.6f %12.6f %12.6f %12.6f %12.6f\n' %
tuple([t / repeat / narrays for t in T]))
out.flush()
from time import time
from gpaw.transformers import Transformer
from gpaw.grid_descriptor import GridDescriptor
from gpaw.mpi import world
ngpts = 80
N_c = (ngpts, ngpts, ngpts)
a = 10.0
gd = GridDescriptor(N_c, (a, a, a))
gdfine = gd.refine()
interpolate = Transformer(gd, gdfine, 3).apply
a1 = gd.empty()
a1[:] = 1.0
f = gdfine.empty()
ta = time()
r = 600
for i in range(r):
interpolate(a1, f)
tb = time()
n = 8 * (1 + 2 + 4) * ngpts**3
print '%.3f GFlops' % (r * n / (tb - ta) * 1e-9)
"""
python: 0.330 GFlops
mpirun -np 2 gpaw-python: 0.500 GFlops
gpaw-python + OMP: 0.432 GFlops
"""
def abstract_boundary(self):
# Abtract the effective potential, hartree potential, and average density
#out from the electrode calculation.
map = {'-': '0', '+': '1'}
data = self.tio.read_data(filename='Lead_' +
map[self.direction], option='Lead')
nn = data['fine_N_c'][2]
ns = data['nspins']
N_c = data['N_c']
cell_cv = data['cell_cv']
pbc_c = data['pbc_c']
#parsize_c = data['parsize_c']
if type(parsize_domain) is int:
parsize_c = None
assert parsize_domain == self.domain_comm.size
else:
parsize_c = parsize_domain
if parsize_c is None:
parsize_c = decompose_domain(N_c, self.domain_comm.size)
parsize_c = np.array(parsize_c)
d1 = N_c[0] // 2
d2 = N_c[1] // 2
vHt_g = data['vHt_g']
vt_sg = data['vt_sg']
nt_sg = data['nt_sg']
rhot_g = data['rhot_g']
vt_sG = data['vt_sG']
nt_sG = data['nt_sG']
self.D_asp = data['D_asp']
self.dH_asp = data['dH_asp']
gd = GridDescriptor(N_c, cell_cv, pbc_c, self.domain_comm, parsize_c)
finegd = gd.refine()
self.boundary_vHt_g = None
self.boundary_vHt_g1 = None
self.boundary_vt_sg_line = None
self.boundary_nt_sg = None
self.boundary_rhot_g_line = None
self.boundary_vt_sG = None
self.boundary_nt_sG = None
if self.tio.domain_comm.rank == 0:
self.boundary_vHt_g = self.slice(nn, vHt_g)
self.boundary_nt_sg = self.slice(nn, nt_sg)
if self.direction == '-':
other_direction= '+'
else:
other_direction= '-'
h = self.h_cz / 2.0
b_vHt_g0 = self.boundary_vHt_g.copy()
b_vHt_g1 = self.boundary_vHt_g.copy()
self.boundary_vHt_g = interpolate_array(b_vHt_g0,
finegd, h,
self.direction)
self.boundary_vHt_g1 = interpolate_array(b_vHt_g1,
finegd, h,
other_direction)
vt_sg = interpolate_array(vt_sg, finegd,
h, self.direction)
self.boundary_vt_sg_line = aa1d(vt_sg)
self.boundary_nt_sg = interpolate_array(self.boundary_nt_sg,
finegd, h, self.direction)
rhot_g = interpolate_array(rhot_g, finegd, h, self.direction)
self.boundary_rhot_g_line = aa1d(rhot_g)
nn /= 2
h *= 2
self.boundary_vt_sG = self.slice(nn, vt_sG)
self.boundary_nt_sG = self.slice(nn, nt_sG)
self.boundary_vt_sG = interpolate_array(self.boundary_vt_sG,
gd, h, self.direction)
self.boundary_nt_sG = interpolate_array(self.boundary_nt_sG,
gd, h, self.direction)
from gpaw.transformers import Transformer import numpy.random as ra from gpaw.grid_descriptor import GridDescriptor p = 0 n = 20 gd1 = GridDescriptor((n, n, n), (8.0, 8.0, 8.0), pbc_c=p) a1 = gd1.zeros() ra.seed(8) a1[:] = ra.random(a1.shape) gd2 = gd1.refine() a2 = gd2.zeros() i = Transformer(gd1, gd2).apply i(a1, a2) assert abs(gd1.integrate(a1) - gd2.integrate(a2)) < 1e-10 r = Transformer(gd2, gd1).apply a2[0] = 0.0 a2[:, 0] = 0.0 a2[:, :, 0] = 0.0 a2[-1] = 0.0 a2[:, -1] = 0.0 a2[:, :, -1] = 0.0 r(a2, a1) assert abs(gd1.integrate(a1) - gd2.integrate(a2)) < 1e-10
def abstract_boundary(self):
# Abtract the effective potential, hartree potential, and average density
#out from the electrode calculation.
map = {'-': '0', '+': '1'}
data = self.tio.read_data(filename='Lead_' + map[self.direction],
option='Lead')
nn = data['fine_N_c'][2]
ns = data['nspins']
N_c = data['N_c']
cell_cv = data['cell_cv']
pbc_c = data['pbc_c']
#parsize_c = data['parsize_c']
if type(parsize_domain) is int:
parsize_c = None
assert parsize_domain == self.domain_comm.size
else:
parsize_c = parsize_domain
if parsize_c is None:
parsize_c = decompose_domain(N_c, self.domain_comm.size)
parsize_c = np.array(parsize_c)
d1 = N_c[0] // 2
d2 = N_c[1] // 2
vHt_g = data['vHt_g']
vt_sg = data['vt_sg']
nt_sg = data['nt_sg']
rhot_g = data['rhot_g']
vt_sG = data['vt_sG']
nt_sG = data['nt_sG']
self.D_asp = data['D_asp']
self.dH_asp = data['dH_asp']
gd = GridDescriptor(N_c, cell_cv, pbc_c, self.domain_comm, parsize_c)
finegd = gd.refine()
self.boundary_vHt_g = None
self.boundary_vHt_g1 = None
self.boundary_vt_sg_line = None
self.boundary_nt_sg = None
self.boundary_rhot_g_line = None
self.boundary_vt_sG = None
self.boundary_nt_sG = None
if self.tio.domain_comm.rank == 0:
self.boundary_vHt_g = self.slice(nn, vHt_g)
self.boundary_nt_sg = self.slice(nn, nt_sg)
if self.direction == '-':
other_direction = '+'
else:
other_direction = '-'
h = self.h_cz / 2.0
b_vHt_g0 = self.boundary_vHt_g.copy()
b_vHt_g1 = self.boundary_vHt_g.copy()
self.boundary_vHt_g = interpolate_array(b_vHt_g0, finegd, h,
self.direction)
self.boundary_vHt_g1 = interpolate_array(b_vHt_g1, finegd, h,
other_direction)
vt_sg = interpolate_array(vt_sg, finegd, h, self.direction)
self.boundary_vt_sg_line = aa1d(vt_sg)
self.boundary_nt_sg = interpolate_array(self.boundary_nt_sg,
finegd, h, self.direction)
rhot_g = interpolate_array(rhot_g, finegd, h, self.direction)
self.boundary_rhot_g_line = aa1d(rhot_g)
nn /= 2
h *= 2
self.boundary_vt_sG = self.slice(nn, vt_sG)
self.boundary_nt_sG = self.slice(nn, nt_sG)
self.boundary_vt_sG = interpolate_array(self.boundary_vt_sG, gd, h,
self.direction)
self.boundary_nt_sG = interpolate_array(self.boundary_nt_sG, gd, h,
self.direction)
# Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
from __future__ import print_function
from gpaw.grid_descriptor import GridDescriptor
from gpaw.transformers import Transformer
import time
n = 6
gda = GridDescriptor((n, n, n))
gdb = gda.refine()
gdc = gdb.refine()
a = gda.zeros()
b = gdb.zeros()
c = gdc.zeros()
inter = Transformer(gdb, gdc, 2).apply
restr = Transformer(gdb, gda, 2).apply
t = time.clock()
for i in range(8 * 300):
inter(b, c)
print(time.clock() - t)
t = time.clock()
for i in range(8 * 3000):
restr(b, a)
print(time.clock() - t)
from time import time
from gpaw.transformers import Transformer
from gpaw.grid_descriptor import GridDescriptor
from gpaw.mpi import world
ngpts = 80
N_c = (ngpts, ngpts, ngpts)
a = 10.0
gd = GridDescriptor(N_c, (a, a, a))
gdfine = gd.refine()
interpolate = Transformer(gd, gdfine, 3).apply
a1 = gd.empty()
a1[:] = 1.0
f = gdfine.empty()
ta = time()
r = 600
for i in range(r):
interpolate(a1, f)
tb = time()
n = 8 * (1 + 2 + 4) * ngpts**3
print '%.3f GFlops' % (r * n / (tb - ta) * 1e-9)
"""
python: 0.330 GFlops
mpirun -np 2 gpaw-python: 0.500 GFlops
gpaw-python + OMP: 0.432 GFlops
"""
# Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
import numpy as np
from gpaw.grid_descriptor import GridDescriptor
from gpaw.transformers import Transformer
n = 20
gd = GridDescriptor((n,n,n))
np.random.seed(8)
a = gd.empty()
a[:] = np.random.random(a.shape)
gd2 = gd.refine()
b = gd2.zeros()
for k in [2, 4, 6, 8]:
inter = Transformer(gd, gd2, k // 2).apply
inter(a, b)
assert abs(gd.integrate(a) - gd2.integrate(b)) < 1e-14
gd2 = gd.coarsen()
b = gd2.zeros()
for k in [2, 4, 6, 8]:
restr = Transformer(gd, gd2, k // 2).apply
restr(a, b)
assert abs(gd.integrate(a) - gd2.integrate(b)) < 1e-14
# complex versions
a = gd.empty(dtype=complex)
a.real = np.random.random(a.shape)
# Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
from gpaw.grid_descriptor import GridDescriptor
from gpaw.transformers import Transformer
import time
n = 6
gda = GridDescriptor((n,n,n))
gdb = gda.refine()
gdc = gdb.refine()
a = gda.zeros()
b = gdb.zeros()
c = gdc.zeros()
inter = Transformer(gdb, gdc, 2).apply
restr = Transformer(gdb, gda, 2).apply
t = time.clock()
for i in range(8*300):
inter(b, c)
print time.clock() - t
t = time.clock()
for i in range(8*3000):
restr(b, a)
print time.clock() - t
# Copyright (C) 2003 CAMP
# Please see the accompanying LICENSE file for further information.
import numpy as np
from gpaw.grid_descriptor import GridDescriptor
from gpaw.transformers import Transformer
n = 20
gd = GridDescriptor((n, n, n))
np.random.seed(8)
a = gd.empty()
a[:] = np.random.random(a.shape)
gd2 = gd.refine()
b = gd2.zeros()
for k in [2, 4, 6, 8]:
inter = Transformer(gd, gd2, k // 2).apply
inter(a, b)
assert abs(gd.integrate(a) - gd2.integrate(b)) < 1e-14
gd2 = gd.coarsen()
b = gd2.zeros()
for k in [2, 4, 6, 8]:
restr = Transformer(gd, gd2, k // 2).apply
restr(a, b)
assert abs(gd.integrate(a) - gd2.integrate(b)) < 1e-14
# complex versions
a = gd.empty(dtype=complex)
a.real = np.random.random(a.shape)
a.imag = np.random.random(a.shape)
