def verify_non_pbc_spacing(self):
atoms = create_random_atoms(self.gd, 1000, "NH3", self.a / 2)
pos_ac = atoms.get_positions()
cellvol = np.linalg.det(self.gd.cell_cv)
if debug:
print "cell volume:", np.abs(
cellvol
) * Bohr ** 3, "Ang^3", cellvol > 0 and "(right handed)" or "(left handed)"
# Loop over non-periodic axes and check minimum distance requirement
for c in np.argwhere(~self.gd.pbc_c).ravel():
a_v = self.gd.cell_cv[(c + 1) % 3]
b_v = self.gd.cell_cv[(c + 2) % 3]
c_v = np.cross(a_v, b_v)
for d in range(2):
# Inwards unit normal vector of d'th cell face of c'th axis
# and point intersected by this plane (d=0,1 / bottom,top).
n_v = np.sign(cellvol) * (1 - 2 * d) * c_v / np.linalg.norm(c_v)
if debug:
print {0: "x", 1: "y", 2: "z"}[c] + "-" + {0: "bottom", 1: "top"}[d] + ":", n_v, "Bohr"
if debug:
print "gd.xxxiucell_cv[%d]~" % c, self.gd.xxxiucell_cv[c] / np.linalg.norm(
self.gd.xxxiucell_cv[c]
), "Bohr"
origin_v = np.dot(d * np.eye(3)[c], self.gd.cell_cv)
d_a = np.dot(pos_ac / Bohr - origin_v[np.newaxis, :], n_v)
if debug:
print "a:", self.a / 2 * Bohr, "min:", np.min(d_a) * Bohr, "max:", np.max(d_a) * Bohr
self.assertAlmostEqual(d_a.min(), self.a / 2, 0) # XXX digits!
def setUp(self):
for virtvar in ['boundaries']:
assert getattr(self,
virtvar) is not None, 'Virtual "%s"!' % virtvar
# Basic unit cell information:
res, N_c = shapeopt(100, self.G**3, 3, 0.2)
#N_c = 4*np.round(np.array(N_c)/4) # makes domain decomposition easier
cell_cv = self.h * np.diag(N_c)
pbc_c = {'zero' : (False,False,False), \
'periodic': (True,True,True), \
'mixed' : (True, False, True)}[self.boundaries]
# Create randomized gas-like atomic configuration on interim grid
tmpgd = GridDescriptor(N_c, cell_cv, pbc_c)
self.atoms = create_random_atoms(tmpgd)
# Create setups
Z_a = self.atoms.get_atomic_numbers()
assert 1 == self.nspins
self.setups = Setups(Z_a, p.setups, p.basis, p.lmax, xc)
self.natoms = len(self.setups)
# Decide how many kpoints to sample from the 1st Brillouin Zone
kpts_c = np.ceil(
(10 / Bohr) / np.sum(cell_cv**2, axis=1)**0.5).astype(int)
kpts_c = tuple(kpts_c * pbc_c + 1 - pbc_c)
self.bzk_kc = kpts2ndarray(kpts_c)
# Set up k-point descriptor
self.kd = KPointDescriptor(self.bzk_kc, self.nspins)
self.kd.set_symmetry(self.atoms, self.setups, p.usesymm)
# Set the dtype
if self.kd.gamma:
self.dtype = float
else:
self.dtype = complex
# Create communicators
parsize, parsize_bands = self.get_parsizes()
assert self.nbands % np.prod(parsize_bands) == 0
domain_comm, kpt_comm, band_comm = distribute_cpus(
parsize, parsize_bands, self.nspins, self.kd.nibzkpts)
self.kd.set_communicator(kpt_comm)
# Set up band descriptor:
self.bd = BandDescriptor(self.nbands, band_comm)
# Set up grid descriptor:
self.gd = GridDescriptor(N_c, cell_cv, pbc_c, domain_comm, parsize)
# Set up kpoint/spin descriptor (to be removed):
self.kd_old = KPointDescriptorOld(self.nspins, self.kd.nibzkpts,
kpt_comm, self.kd.gamma, self.dtype)
def setUp(self):
for virtvar in ['boundaries']:
assert getattr(self,virtvar) is not None, 'Virtual "%s"!' % virtvar
# Basic unit cell information:
res, N_c = shapeopt(100, self.G**3, 3, 0.2)
#N_c = 4*np.round(np.array(N_c)/4) # makes domain decomposition easier
cell_cv = self.h * np.diag(N_c)
pbc_c = {'zero' : (False,False,False), \
'periodic': (True,True,True), \
'mixed' : (True, False, True)}[self.boundaries]
# Create randomized gas-like atomic configuration on interim grid
tmpgd = GridDescriptor(N_c, cell_cv, pbc_c)
self.atoms = create_random_atoms(tmpgd)
# Create setups
Z_a = self.atoms.get_atomic_numbers()
assert 1 == self.nspins
self.setups = Setups(Z_a, p.setups, p.basis, p.lmax, xc)
self.natoms = len(self.setups)
# Decide how many kpoints to sample from the 1st Brillouin Zone
kpts_c = np.ceil((10/Bohr)/np.sum(cell_cv**2,axis=1)**0.5).astype(int)
kpts_c = tuple(kpts_c * pbc_c + 1 - pbc_c)
self.bzk_kc = kpts2ndarray(kpts_c)
# Set up k-point descriptor
self.kd = KPointDescriptor(self.bzk_kc, self.nspins)
self.kd.set_symmetry(self.atoms, self.setups, p.usesymm)
# Set the dtype
if self.kd.gamma:
self.dtype = float
else:
self.dtype = complex
# Create communicators
parsize, parsize_bands = self.get_parsizes()
assert self.nbands % np.prod(parsize_bands) == 0
domain_comm, kpt_comm, band_comm = distribute_cpus(parsize,
parsize_bands, self.nspins, self.kd.nibzkpts)
self.kd.set_communicator(kpt_comm)
# Set up band descriptor:
self.bd = BandDescriptor(self.nbands, band_comm)
# Set up grid descriptor:
self.gd = GridDescriptor(N_c, cell_cv, pbc_c, domain_comm, parsize)
# Set up kpoint/spin descriptor (to be removed):
self.kd_old = KPointDescriptorOld(self.nspins, self.kd.nibzkpts,
kpt_comm, self.kd.gamma, self.dtype)
def setUp(self):
UTDomainParallelSetup.setUp(self)
for virtvar in ['dtype']:
assert getattr(self,virtvar) is not None, 'Virtual "%s"!' % virtvar
# Create randomized atoms
self.atoms = create_random_atoms(self.gd, 5) # also tested: 10xNH3/BDA
# XXX DEBUG START
if False:
from ase import view
view(self.atoms*(1+2*self.gd.pbc_c))
# XXX DEBUG END
# Do we agree on the atomic positions?
pos_ac = self.atoms.get_positions()
pos_rac = np.empty((world.size,)+pos_ac.shape, pos_ac.dtype)
world.all_gather(pos_ac, pos_rac)
if (pos_rac-pos_rac[world.rank,...][np.newaxis,...]).any():
raise RuntimeError('Discrepancy in atomic positions detected.')
# Create setups for atoms
self.Z_a = self.atoms.get_atomic_numbers()
self.setups = Setups(self.Z_a, p.setups, p.basis,
p.lmax, xc)
# K-point descriptor
bzk_kc = np.array([[0, 0, 0]], dtype=float)
self.kd = KPointDescriptor(bzk_kc, 1)
self.kd.set_symmetry(self.atoms, self.setups)
self.kd.set_communicator(self.kpt_comm)
# Create gamma-point dummy wavefunctions
self.wfs = FDWFS(self.gd, self.bd, self.kd, self.setups,
self.block_comm, self.dtype)
spos_ac = self.atoms.get_scaled_positions() % 1.0
self.wfs.set_positions(spos_ac)
self.pt = self.wfs.pt # XXX shortcut
## Also create pseudo partial waveves
#from gpaw.lfc import LFC
#self.phit = LFC(self.gd, [setup.phit_j for setup in self.setups], \
# self.kpt_comm, dtype=self.dtype)
#self.phit.set_positions(spos_ac)
self.r_cG = None
self.buf_G = None
self.psit_nG = None
self.allocate()
def setUp(self):
UTDomainParallelSetup.setUp(self)
for virtvar in ['dtype']:
assert getattr(self,virtvar) is not None, 'Virtual "%s"!' % virtvar
# Create randomized atoms
self.atoms = create_random_atoms(self.gd, 5) # also tested: 10xNH3/BDA
# XXX DEBUG START
if False:
from ase import view
view(self.atoms*(1+2*self.gd.pbc_c))
# XXX DEBUG END
# Do we agree on the atomic positions?
pos_ac = self.atoms.get_positions()
pos_rac = np.empty((world.size,)+pos_ac.shape, pos_ac.dtype)
world.all_gather(pos_ac, pos_rac)
if (pos_rac-pos_rac[world.rank,...][np.newaxis,...]).any():
raise RuntimeError('Discrepancy in atomic positions detected.')
# Create setups for atoms
self.Z_a = self.atoms.get_atomic_numbers()
self.setups = Setups(self.Z_a, p.setups, p.basis,
p.lmax, xc)
# K-point descriptor
bzk_kc = np.array([[0, 0, 0]], dtype=float)
self.kd = KPointDescriptor(bzk_kc, 1)
self.kd.set_symmetry(self.atoms, self.setups, usesymm=True)
self.kd.set_communicator(self.kpt_comm)
# Create gamma-point dummy wavefunctions
self.wfs = FDWFS(self.gd, self.bd, self.kd, self.setups,
self.dtype)
spos_ac = self.atoms.get_scaled_positions() % 1.0
self.wfs.set_positions(spos_ac)
self.pt = self.wfs.pt # XXX shortcut
## Also create pseudo partial waveves
#from gpaw.lfc import LFC
#self.phit = LFC(self.gd, [setup.phit_j for setup in self.setups], \
# self.kpt_comm, dtype=self.dtype)
#self.phit.set_positions(spos_ac)
self.r_cG = None
self.buf_G = None
self.psit_nG = None
self.allocate()
def setUp(self):
UTBandParallelSetup.setUp(self)
for virtvar in ['dtype', 'blocking', 'async']:
assert getattr(self,
virtvar) is not None, 'Virtual "%s"!' % virtvar
# Create randomized atoms
self.atoms = create_random_atoms(self.gd)
# Do we agree on the atomic positions?
pos_ac = self.atoms.get_positions()
pos_rac = np.empty((world.size, ) + pos_ac.shape, pos_ac.dtype)
world.all_gather(pos_ac, pos_rac)
if (pos_rac - pos_rac[world.rank, ...][np.newaxis, ...]).any():
raise RuntimeError('Discrepancy in atomic positions detected.')
# Create setups for atoms
self.Z_a = self.atoms.get_atomic_numbers()
self.setups = Setups(self.Z_a, p.setups, p.basis, p.lmax, xc)
# Create atomic projector overlaps
spos_ac = self.atoms.get_scaled_positions() % 1.0
self.rank_a = self.gd.get_ranks_from_positions(spos_ac)
self.pt = LFC(self.gd, [setup.pt_j for setup in self.setups],
self.kpt_comm,
dtype=self.dtype)
self.pt.set_positions(spos_ac)
if memstats:
# Hack to scramble heap usage into steady-state level
HEAPSIZE = 25 * 1024**2
for i in range(100):
data = np.empty(np.random.uniform(0, HEAPSIZE // 8), float)
del data
self.mem_pre = record_memory()
self.mem_alloc = None
self.mem_test = None
# Stuff for pseudo wave functions and projections
if self.dtype == complex:
self.gamma = 1j**(1.0 / self.nbands)
else:
self.gamma = 1.0
self.psit_nG = None
self.P_ani = None
self.Qeff_a = None
self.Qtotal = None
self.allocate()
def setUp(self):
UTBandParallelSetup.setUp(self)
for virtvar in ['dtype','blocking','async']:
assert getattr(self,virtvar) is not None, 'Virtual "%s"!' % virtvar
# Create randomized atoms
self.atoms = create_random_atoms(self.gd)
# Do we agree on the atomic positions?
pos_ac = self.atoms.get_positions()
pos_rac = np.empty((world.size,)+pos_ac.shape, pos_ac.dtype)
world.all_gather(pos_ac, pos_rac)
if (pos_rac-pos_rac[world.rank,...][np.newaxis,...]).any():
raise RuntimeError('Discrepancy in atomic positions detected.')
# Create setups for atoms
self.Z_a = self.atoms.get_atomic_numbers()
self.setups = Setups(self.Z_a, p.setups, p.basis,
p.lmax, xc)
# Create atomic projector overlaps
spos_ac = self.atoms.get_scaled_positions() % 1.0
self.rank_a = self.gd.get_ranks_from_positions(spos_ac)
self.pt = LFC(self.gd, [setup.pt_j for setup in self.setups],
dtype=self.dtype)
self.pt.set_positions(spos_ac)
if memstats:
# Hack to scramble heap usage into steady-state level
HEAPSIZE = 25 * 1024**2
for i in range(100):
data = np.empty(np.random.uniform(0, HEAPSIZE // 8), float)
del data
self.mem_pre = record_memory()
self.mem_alloc = None
self.mem_test = None
# Stuff for pseudo wave functions and projections
if self.dtype == complex:
self.gamma = 1j**(1.0/self.nbands)
else:
self.gamma = 1.0
self.psit_nG = None
self.P_ani = None
self.Qeff_a = None
self.Qtotal = None
self.allocate()
def verify_non_pbc_spacing(self):
atoms = create_random_atoms(self.gd, 1000, 'NH3', self.a/2)
pos_ac = atoms.get_positions()
cellvol = np.linalg.det(self.gd.cell_cv)
if debug: print 'cell volume:', np.abs(cellvol)*Bohr**3, 'Ang^3', cellvol>0 and '(right handed)' or '(left handed)'
# Loop over non-periodic axes and check minimum distance requirement
for c in np.argwhere(~self.gd.pbc_c).ravel():
a_v = self.gd.cell_cv[(c+1)%3]
b_v = self.gd.cell_cv[(c+2)%3]
c_v = np.cross(a_v, b_v)
for d in range(2):
# Inwards unit normal vector of d'th cell face of c'th axis
# and point intersected by this plane (d=0,1 / bottom,top).
n_v = np.sign(cellvol) * (1-2*d) * c_v / np.linalg.norm(c_v)
if debug: print {0:'x',1:'y',2:'z'}[c]+'-'+{0:'bottom',1:'top'}[d]+':', n_v, 'Bohr'
if debug: print 'gd.xxxiucell_cv[%d]~' % c, self.gd.xxxiucell_cv[c] / np.linalg.norm(self.gd.xxxiucell_cv[c]), 'Bohr'
origin_v = np.dot(d * np.eye(3)[c], self.gd.cell_cv)
d_a = np.dot(pos_ac/Bohr - origin_v[np.newaxis,:], n_v)
if debug: print 'a:', self.a/2*Bohr, 'min:', np.min(d_a)*Bohr, 'max:', np.max(d_a)*Bohr
self.assertAlmostEqual(d_a.min(), self.a/2, 0) #XXX digits!
def verify_non_pbc_spacing(self):
atoms = create_random_atoms(self.gd, 1000, 'NH3', self.a/2)
pos_ac = atoms.get_positions()
cellvol = np.linalg.det(self.gd.cell_cv)
if debug: print 'cell volume:', np.abs(cellvol)*Bohr**3, 'Ang^3', cellvol>0 and '(right handed)' or '(left handed)'
# Loop over non-periodic axes and check minimum distance requirement
for c in np.argwhere(~self.gd.pbc_c).ravel():
a_v = self.gd.cell_cv[(c+1)%3]
b_v = self.gd.cell_cv[(c+2)%3]
c_v = np.cross(a_v, b_v)
for d in range(2):
# Inwards unit normal vector of d'th cell face of c'th axis
# and point intersected by this plane (d=0,1 / bottom,top).
n_v = np.sign(cellvol) * (1-2*d) * c_v / np.linalg.norm(c_v)
if debug: print {0:'x',1:'y',2:'z'}[c]+'-'+{0:'bottom',1:'top'}[d]+':', n_v, 'Bohr'
if debug: print 'gd.xxxiucell_cv[%d]~' % c, self.gd.xxxiucell_cv[c] / np.linalg.norm(self.gd.xxxiucell_cv[c]), 'Bohr'
origin_v = np.dot(d * np.eye(3)[c], self.gd.cell_cv)
d_a = np.dot(pos_ac/Bohr - origin_v[np.newaxis,:], n_v)
if debug: print 'a:', self.a/2*Bohr, 'min:', np.min(d_a)*Bohr, 'max:', np.max(d_a)*Bohr
self.assertAlmostEqual(d_a.min(), self.a/2, 0) #XXX digits!
def setUp(self):
UTDomainParallelSetup.setUp(self)
for virtvar in ["dtype"]:
assert getattr(self, virtvar) is not None, 'Virtual "%s"!' % virtvar
# Set up kpoint descriptor:
self.kd = KPointDescriptor(self.nspins, self.nibzkpts, self.kpt_comm, self.gamma, self.dtype)
# Choose a sufficiently small width of gaussian test functions
cell_c = np.sum(self.gd.cell_cv ** 2, axis=1) ** 0.5
self.sigma = np.min((0.1 + 0.4 * self.gd.pbc_c) * cell_c)
if debug and world.rank == 0:
print "sigma=%8.5f Ang" % (self.sigma * Bohr), "cell_c:", cell_c * Bohr, "Ang", "N_c:", self.gd.N_c
self.atoms = create_random_atoms(self.gd, 4, "H", 4 * self.sigma)
self.r_vG = None
self.wf_uG = None
self.laplace0_uG = None
self.allocate()
def setUp(self):
for virtvar in ['equipartition']:
assert getattr(self,virtvar) is not None, 'Virtual "%s"!' % virtvar
kpts = {'even' : (12,1,2), \
'prime': (23,1,1)}[self.equipartition]
#primes = [i for i in xrange(50,1,-1) if ~np.any(i%np.arange(2,i)==0)]
bzk_kc = kpts2ndarray(kpts)
assert p.usesymm == None
self.nibzkpts = len(bzk_kc)
#parsize_domain, parsize_bands = create_parsize_minbands(self.nbands, world.size)
parsize_domain, parsize_bands = 1, 1 #XXX
assert self.nbands % np.prod(parsize_bands) == 0
domain_comm, kpt_comm, band_comm = distribute_cpus(parsize_domain,
parsize_bands, self.nspins, self.nibzkpts)
# Set up band descriptor:
self.bd = BandDescriptor(self.nbands, band_comm, p.parallel['stridebands'])
# Set up grid descriptor:
res, ngpts = shapeopt(300, self.G**3, 3, 0.2)
cell_c = self.h * np.array(ngpts)
pbc_c = (True, False, True)
self.gd = GridDescriptor(ngpts, cell_c, pbc_c, domain_comm, parsize_domain)
# Create randomized gas-like atomic configuration
self.atoms = create_random_atoms(self.gd)
# Create setups
Z_a = self.atoms.get_atomic_numbers()
self.setups = Setups(Z_a, p.setups, p.basis, p.lmax, xc)
self.natoms = len(self.setups)
# Set up kpoint descriptor:
self.kd = KPointDescriptor(bzk_kc, self.nspins)
self.kd.set_symmetry(self.atoms, self.setups, usesymm=p.usesymm)
self.kd.set_communicator(kpt_comm)
def setUp(self):
UTDomainParallelSetup.setUp(self)
for virtvar in ['dtype']:
assert getattr(self,virtvar) is not None, 'Virtual "%s"!' % virtvar
# Set up kpoint descriptor:
self.kd = KPointDescriptor(self.nspins, self.nibzkpts, self.kpt_comm, \
self.gamma, self.dtype)
# Choose a sufficiently small width of gaussian test functions
cell_c = np.sum(self.gd.cell_cv**2, axis=1)**0.5
self.sigma = np.min((0.1+0.4*self.gd.pbc_c)*cell_c)
if debug and world.rank == 0:
print 'sigma=%8.5f Ang' % (self.sigma*Bohr), 'cell_c:', cell_c*Bohr, 'Ang', 'N_c:', self.gd.N_c
self.atoms = create_random_atoms(self.gd, 4, 'H', 4*self.sigma)
self.r_vG = None
self.wf_uG = None
self.laplace0_uG = None
self.allocate()
def setUp(self):
for virtvar in ['equipartition']:
assert getattr(self,virtvar) is not None, 'Virtual "%s"!' % virtvar
kpts = {'even' : (12,1,2), \
'prime': (23,1,1)}[self.equipartition]
#primes = [i for i in xrange(50,1,-1) if ~np.any(i%np.arange(2,i)==0)]
bzk_kc = kpts2ndarray(kpts)
assert p.usesymm == None
self.nibzkpts = len(bzk_kc)
#parsize, parsize_bands = create_parsize_minbands(self.nbands, world.size)
parsize, parsize_bands = 1, 1 #XXX
assert self.nbands % np.prod(parsize_bands) == 0
domain_comm, kpt_comm, band_comm = distribute_cpus(parsize,
parsize_bands, self.nspins, self.nibzkpts)
# Set up band descriptor:
self.bd = BandDescriptor(self.nbands, band_comm, p.parallel['stridebands'])
# Set up grid descriptor:
res, ngpts = shapeopt(300, self.G**3, 3, 0.2)
cell_c = self.h * np.array(ngpts)
pbc_c = (True, False, True)
self.gd = GridDescriptor(ngpts, cell_c, pbc_c, domain_comm, parsize)
# Create randomized gas-like atomic configuration
self.atoms = create_random_atoms(self.gd)
# Create setups
Z_a = self.atoms.get_atomic_numbers()
self.setups = Setups(Z_a, p.setups, p.basis, p.lmax, xc)
self.natoms = len(self.setups)
# Set up kpoint descriptor:
self.kd = KPointDescriptor(bzk_kc, self.nspins)
self.kd.set_symmetry(self.atoms, self.setups, p.usesymm)
self.kd.set_communicator(kpt_comm)
