def __init__(self, v, center=None, origin=None): v = _a.asarrayd(v) if v.size == 1: self._v = np.identity(3) * v # a "Euclidean" cube elif v.size == 3: self._v = np.diag(v.ravel()) # a "Euclidean" rectangle elif v.size == 9: self._v = v.reshape(3, 3).astype(np.float64) else: raise ValueError( f"{self.__class__.__name__} requires initialization with 3 vectors defining the cuboid" ) if center is not None and origin is not None: raise ValueError( f"{self.__class__.__name__} only allows either origin or center argument" ) elif origin is not None: center = self._v.sum(0) / 2 + origin # initialize the center super().__init__(center) # Create the reciprocal cell self._iv = inv(self._v)
def test_inv1(): np.random.seed(1204982) a = np.random.rand(10, 10) ac = a.copy() xs = sl.inv(a) x = inv(a) assert np.allclose(xs, x) assert np.allclose(a, ac)
def __init__(self, v, center=None): super(Cuboid, self).__init__(center) v = _a.asarrayd(v) if v.size == 1: self._v = np.identity(3) * v # a "Euclidean" cube elif v.size == 3: self._v = np.diag(v.ravel()) # a "Euclidean" rectangle elif v.size == 9: self._v = v.reshape(3, 3).astype(np.float64) else: raise ValueError(self.__class__.__name__ + " requires initialization with 3 vectors defining the cuboid") # Create the reciprocal cell self._iv = inv(self._v)
def _calc_green(k, no, tile, idx0): Gf, A2 = SE(E, k, dtype=dtype, bulk=True) # A1 == Gf, because of memory usage tY = M1Sk(k, dtype=dtype, format='array') # S tX = M1Pk(k, dtype=dtype, format='array') # H B = tY * E - tX # C = _conj(tY.T) * E - _conj(tX.T) tY = solve(Gf, conjugate(tY.T) * E - conjugate(tX.T), True, True) Gf = inv(A2 - dot(B, tY), True) tX = solve(A2, B, True, True) G = empty([tile, no, tile, no], dtype=dtype) G[idx0, :, idx0, :] = Gf.reshape(1, no, no) for i in range(1, tile): G[idx0[i:], :, idx0[:-i], :] = - dot(tX, G[i-1, :, 0, :]).reshape(1, no, no) G[idx0[:-i], :, idx0[i:], :] = - dot(tY, G[0, :, i-1, :]).reshape(1, no, no) return G.reshape(tile * no, -1)
def _calc_green(k, no, tile, idx0): # Calculate left/right self-energies Gf, A2 = SE(E, k, dtype=dtype, bulk=True) # A1 == Gf, because of memory usage B = - M1Pk(k, dtype=dtype, format='array') # C = conjugate(B.T) tY = solve(Gf, conjugate(B.T), True, True) Gf = inv(A2 - dot(B, tY), True) tX = solve(A2, B, True, True) # Since this is the pristine case, we know that # G11 and G22 are the same: # G = [A1 - C.tX]^-1 == [A2 - B.tY]^-1 G = empty([tile, no, tile, no], dtype=dtype) G[idx0, :, idx0, :] = Gf.reshape(1, no, no) for i in range(1, tile): G[idx0[i:], :, idx0[:-i], :] = - dot(tX, G[i-1, :, 0, :]).reshape(1, no, no) G[idx0[:-i], :, idx0[i:], :] = - dot(tY, G[0, :, i-1, :]).reshape(1, no, no) return G.reshape(tile * no, -1)
def self_energy(self, E, bulk=False, coupling=False, dtype=None): r""" Calculate the real-space self-energy The real space self-energy is calculated via: .. math:: \boldsymbol\Sigma^{\mathcal{R}}(E) = \mathbf S^{\mathcal{R}} E - \mathbf H^{\mathcal{R}} - \sum_{\mathbf k} \mathbf G_{\mathbf k}(E) Parameters ---------- E : float/complex energy to evaluate the real-space self-energy at bulk : bool, optional if true, :math:`\mathbf S^{\mathcal{R}} E - \mathbf H^{\mathcal{R}} - \boldsymbol\Sigma^\mathcal{R}` is returned, otherwise :math:`\boldsymbol\Sigma^\mathcal{R}` is returned dtype : numpy.dtype, optional the resulting data type, default to ``np.complex128`` coupling: bool, optional if True, only the self-energy terms located on the coupling geometry (`coupling_geometry`) are returned """ if dtype is None: dtype = complex128 if E.imag == 0: E = E.real + 1j * self._options['eta'] invG = inv(self.green(E, dtype=dtype), True) if coupling: orbs = self._calc['orbs'] if bulk: return invG[orbs, orbs.T] return ((self._calc['S0'] * E - self._calc['P0']).astype(dtype, copy=False).toarray() - invG)[orbs, orbs.T] else: if bulk: return invG return (self._calc['S0'] * E - self._calc['P0']).astype(dtype, copy=False).toarray() - invG
def test_rcell(self, setup): # LAPACK inverse algorithm implicitly does # a transpose. rcell = lin.inv(setup.sc.cell) * 2. * np.pi assert np.allclose(rcell.T, setup.sc.rcell) assert np.allclose(rcell.T / (2 * np.pi), setup.sc.icell)
def _calc_green(k, no, tile, idx0): SL, SR = SE(E, k, dtype=dtype) return inv(M0Sk(k, dtype=dtype, format='array') * E - M0Pk(k, dtype=dtype, format='array') - SL - SR, True)