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 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)