hamop 0.1.0__py3-none-any.whl

hamop/__init__.py

@@ -0,0 +1,29 @@
+"""hamop: one tight-binding Hamiltonian, every observable, strictly consistent.
+
+Build a Hamiltonian once, as real-space blocks in an orthogonal or
+nonorthogonal basis, and compute its band structure, density of states,
+Kubo-Greenwood optical conductivity and Landauer transmission from the
+same matrices, so that spectral, optical and transport statements about
+one model can never drift apart.
+
+Methodological basis: the study "Learning the quantum Hamiltonian of
+defective monolayer MoS2 reveals collective vacancy brightness
+decoupled from defect count" (code:
+https://github.com/Tanvir-Mahmud-Mahim/mos2-vacancy-optics); this
+package is the general-purpose engine distilled from that pipeline.
+"""
+from .eigsolve import gen_eigh
+from .kubo import carrier_count, sigma_optical
+from .lattices import chain_lead_blocks, graphene, linear_chain, two_site
+from .model import TightBindingModel
+from .negf import sancho_rubio, transmission, transmission_direct
+from .spectrum import band_edges, bands, dos, fermi_level
+
+__version__ = "0.1.0"
+__all__ = [
+    "TightBindingModel", "gen_eigh",
+    "bands", "dos", "fermi_level", "band_edges",
+    "sigma_optical", "carrier_count",
+    "sancho_rubio", "transmission", "transmission_direct",
+    "linear_chain", "two_site", "graphene", "chain_lead_blocks",
+]

hamop/eigsolve.py

@@ -0,0 +1,42 @@
+"""Generalized eigensolver with canonical orthogonalization.
+
+A nonorthogonal basis can be mildly overcomplete, so the overlap matrix
+S has eigenvalues close to zero.  Errors in H that live in that
+near-null space are amplified enormously by a naive generalized
+eigensolver.  Canonical orthogonalization is the standard remedy used
+inside electronic-structure codes (Szabo and Ostlund, *Modern Quantum
+Chemistry*, sec. 3.4.5): diagonalize S, drop directions whose overlap
+eigenvalue falls below a threshold, and solve H in the remaining
+well-conditioned subspace.
+
+For a well-conditioned S this reduces to the ordinary generalized
+eigenproblem; the test suite asserts agreement with
+``scipy.linalg.eigh(H, S)`` to near machine precision in that case.
+"""
+from __future__ import annotations
+
+import numpy as np
+from scipy.linalg import eigh
+
+__all__ = ["gen_eigh"]
+
+
+def gen_eigh(H, S, thresh=1e-10, eigvals_only=True):
+    """Eigenvalues (and vectors) of H c = e S c, canonically orthogonalized.
+
+    thresh: overlap eigenvalues below this are dropped.  Returned
+    eigenvectors are columns in the original basis, S-orthonormal within
+    the kept subspace.
+    """
+    H = 0.5 * (H + np.conj(H).T)
+    S = 0.5 * (S + np.conj(S).T)
+    s, U = eigh(S)
+    keep = s > thresh
+    if not np.any(keep):
+        raise ValueError("no overlap eigenvalue above the threshold")
+    X = U[:, keep] / np.sqrt(s[keep])
+    Hp = X.conj().T @ H @ X
+    if eigvals_only:
+        return eigh(Hp, eigvals_only=True)
+    w, Vp = eigh(Hp)
+    return w, X @ Vp

hamop/kubo.py

@@ -0,0 +1,96 @@
+"""Kubo-Greenwood optical conductivity from the same Bloch matrices.
+
+The velocity operator uses the standard atomistic (Peierls-like)
+position gauge: the position operator is taken diagonal at the sites,
+so dH/dk carries a factor of the inter-site displacement and the
+intra-atomic dipole contribution is neglected -- the common
+approximation in tight-binding optics.  In a nonorthogonal basis the
+interband matrix element at k is
+
+    M_nm = <n| dH/dk - (e_n + e_m)/2  dS/dk |m>,
+
+which is what makes the result invariant under a rigid shift
+H -> H + c S of the energy zero; the test suite asserts that
+invariance to near machine precision, along with the textbook anchors
+described in the README.
+
+Convention: the real part of the sheet conductivity is returned in
+units of e^2 / (4 hbar) -- for reference, that unit is exactly the
+universal optical sheet conductivity of graphene (Kuzmenko et al.,
+Phys. Rev. Lett. 100, 117401 (2008)), and the test suite reproduces
+sigma = 1 on the graphene plateau from the nearest-neighbour model.
+Spin degeneracy enters as the explicit factor ``spin`` (default 2).
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from .eigsolve import gen_eigh
+
+__all__ = ["sigma_optical", "carrier_count"]
+
+KB = 8.617333262e-5  # eV / K
+
+
+def sigma_optical(model, omega, mu, mesh=None, kpts=None, weights=None,
+                  T=300.0, eta=0.05, direction=0, spin=2, thresh=1e-10):
+    """Real part of the optical sheet conductivity, in units of e^2/(4 hbar).
+
+    omega: photon energies (eV, > 0).  mu: chemical potential (eV).
+    eta: Gaussian broadening of the energy-conservation delta (eV).
+    direction: Cartesian polarization axis.  For a finite system
+    (cell=None) the "cell volume" is absent and the result is the
+    conductivity times the system area; divide by your geometric area.
+    """
+    omega = np.asarray(omega, dtype=float)
+    if np.any(omega <= 0):
+        raise ValueError("omega must be positive photon energies")
+    if mesh is not None or kpts is not None:
+        if mesh is not None:
+            kpts, weights = model.monkhorst_pack(mesh)
+        elif weights is None:
+            weights = np.full(len(kpts), 1.0 / len(kpts))
+        area = model.cell_volume
+    else:
+        if model.cell is not None:
+            raise ValueError("periodic model: give mesh or kpts")
+        kpts, weights, area = [None], [1.0], 1.0
+
+    sig = np.zeros_like(omega)
+    for k, w in zip(kpts, weights):
+        H, S = model.bloch(k)
+        dH, dS = model.bloch_derivative(k, direction)
+        e, c = gen_eigh(H, S, thresh=thresh, eigvals_only=False)
+        x = np.clip((e - mu) / (KB * T), -60.0, 60.0)
+        f = 1.0 / (1.0 + np.exp(x))
+        M = c.conj().T @ dH @ c
+        Sd = c.conj().T @ dS @ c
+        M = M - 0.5 * (e[:, None] + e[None, :]) * Sd
+        dE = e[None, :] - e[:, None]          # E_m - E_n
+        df = f[:, None] - f[None, :]          # f_n - f_m
+        A2 = np.abs(M) ** 2
+        mask = dE > 1e-3
+        for iw, hw in enumerate(omega):
+            g = np.exp(-0.5 * ((dE - hw) / eta) ** 2) \
+                / (eta * np.sqrt(2.0 * np.pi))
+            sig[iw] += w * (df * A2 * g / np.where(mask, dE, 1.0))[mask].sum()
+    # sigma / (e^2 / 4 hbar) = spin * 4 pi / area * sum, M in eV*A, dE in eV
+    return sig * spin * 4.0 * np.pi / area
+
+
+def carrier_count(model, mu, mesh=None, kpts=None, weights=None, T=300.0,
+                  spin=2, thresh=1e-10):
+    """Mean number of occupied states per unit cell (spin included)."""
+    if mesh is not None:
+        kpts, weights = model.monkhorst_pack(mesh)
+    elif kpts is None:
+        kpts, weights = [None], [1.0]
+    elif weights is None:
+        weights = np.full(len(kpts), 1.0 / len(kpts))
+    n = 0.0
+    for k, w in zip(kpts, weights):
+        H, S = model.bloch(k)
+        e = gen_eigh(H, S, thresh=thresh)
+        x = np.clip((e - mu) / (KB * T), -60.0, 60.0)
+        n += w * spin * float((1.0 / (1.0 + np.exp(x))).sum())
+    return n

hamop/lattices.py

@@ -0,0 +1,67 @@
+"""Reference lattices with closed-form physics, for tests and examples.
+
+These builders exist because every one of them has textbook exact
+results the package is validated against: the chain's dispersion, its
+density of states and its unit transmission; the two-site molecule's
+single absorption line; graphene's Dirac cones and universal optical
+sheet conductivity.  They double as templates for building your own
+models.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from .model import TightBindingModel
+
+__all__ = ["linear_chain", "two_site", "graphene", "chain_lead_blocks"]
+
+
+def linear_chain(t=-1.0, e0=0.0, a=1.0, s=None):
+    """Infinite single-orbital chain: E(k) = e0 + 2 t cos(k a).
+
+    s: optional nearest-neighbour overlap (nonorthogonal chain).
+    """
+    m = TightBindingModel(positions=[[0.0]], norb=1, cell=[[a]])
+    m.add_hop(0, 0, (0,), [[e0]],
+              None if s is None else [[1.0]])
+    m.add_hop(0, 0, (1,), [[t]],
+              None if s is None else [[s]])
+    return m
+
+
+def two_site(t=-1.0, e0=0.0, a=1.0, s=None):
+    """Finite two-site molecule: levels e0 -/+ |t| (orthogonal case),
+    one optical transition at 2|t|."""
+    m = TightBindingModel(positions=[[0.0], [a]], norb=1, cell=None)
+    m.add_hop(0, 0, (0,), [[e0]], None if s is None else [[1.0]])
+    m.add_hop(1, 1, (0,), [[e0]], None if s is None else [[1.0]])
+    m.add_hop(0, 1, (0,), [[t]], None if s is None else [[s]])
+    return m
+
+
+def graphene(t=-2.7, a=2.46):
+    """Nearest-neighbour graphene: Dirac cones at K, bandwidth 6|t|,
+    and the universal optical sheet conductivity e^2/(4 hbar) on the
+    interband plateau."""
+    cell = a * np.array([[1.0, 0.0], [0.5, np.sqrt(3.0) / 2.0]])
+    pos = np.array([np.zeros(2), (cell[0] + cell[1]) / 3.0])
+    m = TightBindingModel(positions=pos, norb=1, cell=cell)
+    m.add_hop(0, 1, (0, 0), [[t]])
+    m.add_hop(0, 1, (-1, 0), [[t]])
+    m.add_hop(0, 1, (0, -1), [[t]])
+    return m
+
+
+def chain_lead_blocks(t=-1.0, e0=0.0, per_layer=1):
+    """Principal-layer blocks of the single-orbital chain lead, with
+    ``per_layer`` sites per layer, for the NEGF module."""
+    n = per_layer
+    H00 = np.zeros((n, n), dtype=complex)
+    for i in range(n):
+        H00[i, i] = e0
+        if i + 1 < n:
+            H00[i, i + 1] = t
+            H00[i + 1, i] = np.conj(t)
+    H01 = np.zeros((n, n), dtype=complex)
+    H01[n - 1, 0] = t
+    return H00, H01

hamop/model.py

@@ -0,0 +1,209 @@
+"""The tight-binding model container: real-space blocks in, Bloch matrices out.
+
+A model is a set of sites, each carrying ``norb`` orbitals, and a set of
+directed hoppings between sites.  Each hopping is stored once, as
+``(i, j, image, H_block, S_block)``: the block couples the orbitals of
+site ``i`` in the home cell to the orbitals of site ``j`` in the cell
+displaced by the integer lattice vector ``image``.  The Hermitian
+partner (``j`` back to ``i`` in the opposite image) is implied and added
+by the assembly, so a bond is never double-counted.  On-site blocks
+(``i == j`` and zero image) must be Hermitian themselves.
+
+Assembly follows the standard atomic-gauge convention: the Bloch phase
+of a block is ``exp(i k . d)`` with ``d`` the *Cartesian* displacement
+from site ``i`` to site ``j`` including the lattice vector, so the
+k-derivative of the Hamiltonian carries a factor ``i d`` per block.
+That derivative is exactly what the Kubo velocity operator needs, which
+is why the two live in one class: the optics and the spectrum can never
+drift out of sync with each other.
+
+Units: energies in eV, positions in Angstrom, k in 1/Angstrom.  Finite
+(non-periodic) systems are models with ``cell=None`` and only zero
+images; every observable then works at the single "k-point" k = 0.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["TightBindingModel"]
+
+
+class TightBindingModel:
+    """Sites, orbitals and directed hopping blocks; assembles H(k), S(k).
+
+    positions: (nsite, dim) Cartesian site positions (Angstrom).
+    norb: int or sequence, orbitals per site.
+    cell: (dim, dim) lattice vectors as rows (Angstrom), or None for a
+    finite system.
+    """
+
+    def __init__(self, positions, norb, cell=None):
+        self.positions = np.atleast_2d(np.asarray(positions, dtype=float))
+        n_site = self.positions.shape[0]
+        if np.isscalar(norb):
+            self.norb = np.full(n_site, int(norb))
+        else:
+            self.norb = np.asarray(norb, dtype=int)
+            if self.norb.shape != (n_site,):
+                raise ValueError("norb must be scalar or one entry per site")
+        self.cell = None if cell is None else np.atleast_2d(
+            np.asarray(cell, dtype=float))
+        self.offsets = np.concatenate([[0], np.cumsum(self.norb)])
+        self.nao = int(self.offsets[-1])
+        self._hops = []
+
+    # ------------------------------------------------------------------
+    def add_hop(self, i, j, image, H_block, S_block=None):
+        """Add one directed hopping block (the reverse partner is implied).
+
+        image: integer lattice vector of the cell containing site j
+        (all zeros for a finite system or an intra-cell bond).
+        H_block: (norb_i, norb_j) array.  S_block defaults to zero for
+        an inter-site block; identity is used automatically for on-site
+        blocks when no overlap is given anywhere (orthogonal basis).
+        """
+        i, j = int(i), int(j)
+        image = tuple(int(m) for m in np.atleast_1d(image))
+        if self.cell is None and any(image):
+            raise ValueError("finite system: image must be zero")
+        H_block = np.asarray(H_block, dtype=complex)
+        if H_block.shape != (self.norb[i], self.norb[j]):
+            raise ValueError(
+                f"H block shape {H_block.shape} != "
+                f"({self.norb[i]}, {self.norb[j]}) for sites ({i}, {j})")
+        onsite = (i == j) and not any(image)
+        if onsite and not np.allclose(H_block, H_block.conj().T):
+            raise ValueError("on-site block must be Hermitian")
+        if S_block is not None:
+            S_block = np.asarray(S_block, dtype=complex)
+            if S_block.shape != H_block.shape:
+                raise ValueError("S block shape must match H block shape")
+            if onsite and not np.allclose(S_block, S_block.conj().T):
+                raise ValueError("on-site overlap block must be Hermitian")
+        self._hops.append((i, j, image, H_block, S_block))
+
+    def has_overlap(self):
+        return any(h[4] is not None for h in self._hops)
+
+    # ------------------------------------------------------------------
+    def _displacement(self, i, j, image):
+        d = self.positions[j] - self.positions[i]
+        if self.cell is not None:
+            d = d + np.asarray(image, dtype=float) @ self.cell
+        return d
+
+    def _terms(self):
+        """Yield (oi, oj, d, Hb, Sb) for every block and its implied
+        Hermitian partner, exactly once each."""
+        overlap = self.has_overlap()
+        seen_onsite_S = set()
+        for i, j, image, Hb, Sb in self._hops:
+            oi, oj = self.offsets[i], self.offsets[j]
+            d = self._displacement(i, j, image)
+            onsite = (i == j) and not any(image)
+            if Sb is None:
+                if onsite and overlap:
+                    Sb = np.eye(self.norb[i], dtype=complex)
+                else:
+                    Sb = np.zeros_like(Hb)
+            if onsite:
+                seen_onsite_S.add(i)
+                yield oi, oj, d, Hb, Sb
+            else:
+                yield oi, oj, d, Hb, Sb
+                yield oj, oi, -d, Hb.conj().T, Sb.conj().T
+        if overlap:
+            # sites whose on-site block was never given still need S = 1
+            given = {i for i, j, im, _, _ in self._hops
+                     if i == j and not any(im)}
+            for i in range(len(self.norb)):
+                if i not in given:
+                    oi = self.offsets[i]
+                    yield (oi, oi, np.zeros(self.positions.shape[1]),
+                           np.zeros((self.norb[i], self.norb[i]), complex),
+                           np.eye(self.norb[i], dtype=complex))
+
+    # ------------------------------------------------------------------
+    def bloch(self, k=None):
+        """H(k), S(k) as dense Hermitian matrices.
+
+        k: Cartesian wave vector (1/Angstrom); None means k = 0.  For a
+        finite system pass None.  S(k) is the identity when the model
+        has no overlap blocks (orthogonal basis).
+        """
+        k = self._kvec(k)
+        H = np.zeros((self.nao, self.nao), dtype=complex)
+        S = np.zeros((self.nao, self.nao), dtype=complex)
+        overlap = self.has_overlap()
+        for oi, oj, d, Hb, Sb in self._terms():
+            ph = np.exp(1j * float(k @ d))
+            ni, nj = Hb.shape
+            H[oi:oi + ni, oj:oj + nj] += ph * Hb
+            S[oi:oi + ni, oj:oj + nj] += ph * Sb
+        H = 0.5 * (H + H.conj().T)
+        if overlap:
+            S = 0.5 * (S + S.conj().T)
+        else:
+            S = np.eye(self.nao, dtype=complex)
+        return H, S
+
+    def bloch_derivative(self, k=None, direction=0):
+        """dH/dk and dS/dk along a Cartesian direction, at wave vector k.
+
+        These are the matrices the Kubo velocity operator is built from;
+        they are Hermitian by construction because every block enters
+        together with its reversed partner at -d.
+        """
+        k = self._kvec(k)
+        dH = np.zeros((self.nao, self.nao), dtype=complex)
+        dS = np.zeros((self.nao, self.nao), dtype=complex)
+        for oi, oj, d, Hb, Sb in self._terms():
+            ph = 1j * d[direction] * np.exp(1j * float(k @ d))
+            ni, nj = Hb.shape
+            dH[oi:oi + ni, oj:oj + nj] += ph * Hb
+            dS[oi:oi + ni, oj:oj + nj] += ph * Sb
+        dH = 0.5 * (dH + dH.conj().T)
+        dS = 0.5 * (dS + dS.conj().T)
+        return dH, dS
+
+    def _kvec(self, k):
+        dim = self.positions.shape[1]
+        if k is None:
+            return np.zeros(dim)
+        k = np.atleast_1d(np.asarray(k, dtype=float))
+        if k.shape != (dim,):
+            raise ValueError(f"k must have dimension {dim}")
+        return k
+
+    # ------------------------------------------------------------------
+    def monkhorst_pack(self, mesh):
+        """Uniform Gamma-centered k-grid over the Brillouin zone.
+
+        mesh: number of points per reciprocal direction (int or sequence
+        matching the cell dimension).  Returns (kpts_cart, weights) with
+        weights summing to one.
+        """
+        if self.cell is None:
+            raise ValueError("finite system has no Brillouin zone")
+        dim = self.cell.shape[0]
+        if np.isscalar(mesh):
+            mesh = (int(mesh),) * dim
+        recip = 2.0 * np.pi * np.linalg.inv(self.cell).T
+        grids = [np.arange(n) / n for n in mesh]
+        frac = np.stack(np.meshgrid(*grids, indexing="ij"),
+                        axis=-1).reshape(-1, dim)
+        kpts = frac @ recip
+        w = np.full(len(kpts), 1.0 / len(kpts))
+        return kpts, w
+
+    @property
+    def cell_volume(self):
+        """Length / area / volume of the unit cell (Angstrom^dim)."""
+        if self.cell is None:
+            raise ValueError("finite system has no cell")
+        c = self.cell
+        if c.shape == (1, 1):
+            return float(abs(c[0, 0]))
+        if c.shape == (2, 2):
+            return float(abs(np.linalg.det(c)))
+        return float(abs(np.linalg.det(c)))

hamop/negf.py

@@ -0,0 +1,163 @@
+"""Landauer transmission by nonequilibrium Green functions.
+
+Two-probe geometry: a device of N principal layers between two
+semi-infinite periodic leads, with only nearest-layer coupling (choose
+the principal layer at least as wide as the interaction range).  The
+surface Green function of each lead is computed by the Sancho-Rubio
+decimation (M. P. Lopez Sancho, J. M. Lopez Sancho and J. Rubio,
+J. Phys. F 15, 851 (1985)); the device is traversed by the standard
+recursive Green function sweep, and the transmission is the Caroli
+trace  T = Tr[ Gamma_R G Gamma_L G^dagger ].
+
+Everything takes explicit layer blocks, so any Hamiltonian source --
+built by hand, assembled from a TightBindingModel supercell, or
+imported from an LCAO code -- can be pushed through the same
+transmission function.  Nonorthogonal bases are supported throughout
+(energy-dependent coupling z S - H).
+
+The test suite checks the analytic single-band chain: unit transmission
+across the band and zero outside, the closed-form surface Green
+function, the closed-form single-impurity transmission, and exact
+agreement between the recursive sweep and a direct inversion of the
+full device Green function.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["sancho_rubio", "transmission", "transmission_direct"]
+
+
+def sancho_rubio(E, H00, H01, S00=None, S01=None, eta=1e-6, maxiter=400,
+                 tol=1e-12):
+    """Retarded surface Green function of a semi-infinite periodic lead.
+
+    H00: principal-layer block; H01: coupling from one layer to the
+    next deeper layer.  S blocks default to identity / zero
+    (orthogonal basis).
+    """
+    n = len(H00)
+    S00 = np.eye(n, dtype=complex) if S00 is None else S00
+    S01 = np.zeros_like(H01) if S01 is None else S01
+    z = E + 1j * eta
+    a = z * S01 - H01
+    b = a.conj().T
+    es = e = z * S00 - H00
+    I = np.eye(n, dtype=complex)
+    for _ in range(maxiter):
+        g = np.linalg.solve(e, I)
+        ab = a @ g @ b
+        ba = b @ g @ a
+        es = es - ab
+        e = e - ab - ba
+        a = a @ g @ a
+        b = b @ g @ b
+        if np.abs(a).max() + np.abs(b).max() < tol:
+            break
+    return np.linalg.solve(es, I)
+
+
+def _lead_sigmas(E, lead_H00, lead_H01, lead_S00, lead_S01, eta):
+    """Self-energies and broadenings of the left and right leads."""
+    z = E + 1j * eta
+    gL = sancho_rubio(E, lead_H00, lead_H01.conj().T, lead_S00,
+                      None if lead_S01 is None else lead_S01.conj().T, eta)
+    gR = sancho_rubio(E, lead_H00, lead_H01, lead_S00, lead_S01, eta)
+    S01 = np.zeros_like(lead_H01) if lead_S01 is None else lead_S01
+    tau = z * S01 - lead_H01
+    sigL = tau.conj().T @ gL @ tau
+    sigR = tau @ gR @ tau.conj().T
+    gamL = 1j * (sigL - sigL.conj().T)
+    gamR = 1j * (sigR - sigR.conj().T)
+    return sigL, sigR, gamL, gamR
+
+
+def transmission(E_list, layers_H, coup_H, lead_H00, lead_H01,
+                 layers_S=None, coup_S=None, lead_S00=None, lead_S01=None,
+                 eta=1e-6):
+    """T(E) by the recursive Green function sweep.
+
+    layers_H[i]: on-layer Hamiltonian of device layer i.
+    coup_H[i]: coupling from layer i to layer i+1 (N-1 blocks).
+    lead_H00 / lead_H01: principal layer of the identical left and right
+    leads.  The outermost device layers must couple to the leads through
+    lead_H01, i.e. they must be lead-like at their outer edge.
+    """
+    N = len(layers_H)
+    layers_S = [None] * N if layers_S is None else layers_S
+    coup_S = [None] * (N - 1) if coup_S is None else coup_S
+    T = np.zeros(len(E_list))
+    for iE, E in enumerate(E_list):
+        z = E + 1j * eta
+        sigL, sigR, gamL, gamR = _lead_sigmas(
+            E, lead_H00, lead_H01, lead_S00, lead_S01, eta)
+        Gs = []
+        g_prev = None
+        for i in range(N):
+            Si = layers_S[i]
+            h_eff = (z * (np.eye(len(layers_H[i])) if Si is None else Si)
+                     - layers_H[i])
+            if i == 0:
+                h_eff = h_eff - sigL
+            if i == N - 1:
+                h_eff = h_eff - sigR
+            if i == 0:
+                g_prev = np.linalg.inv(h_eff)
+            else:
+                Sc = coup_S[i - 1]
+                tau = (z * (np.zeros_like(coup_H[i - 1]) if Sc is None
+                            else Sc) - coup_H[i - 1])
+                g_prev = np.linalg.inv(h_eff - tau.conj().T @ g_prev @ tau)
+            Gs.append(g_prev)
+        prod = Gs[-1]
+        for i in range(N - 2, -1, -1):
+            Sc = coup_S[i]
+            tau = (z * (np.zeros_like(coup_H[i]) if Sc is None else Sc)
+                   - coup_H[i])
+            prod = prod @ tau.conj().T @ Gs[i]
+        G1N = prod          # G_{N,1}: right edge <- left edge
+        T[iE] = float(np.real(np.trace(
+            gamR @ G1N @ gamL @ G1N.conj().T)))
+    return T
+
+
+def transmission_direct(E_list, layers_H, coup_H, lead_H00, lead_H01,
+                        layers_S=None, coup_S=None, lead_S00=None,
+                        lead_S01=None, eta=1e-6):
+    """T(E) by direct inversion of the full device Green function.
+
+    Numerically exact reference for :func:`transmission` on small
+    devices; the recursive sweep must agree with this to machine
+    precision, and the test suite asserts that it does.
+    """
+    N = len(layers_H)
+    layers_S = [None] * N if layers_S is None else layers_S
+    coup_S = [None] * (N - 1) if coup_S is None else coup_S
+    sizes = [len(h) for h in layers_H]
+    offs = np.concatenate([[0], np.cumsum(sizes)])
+    ntot = offs[-1]
+    T = np.zeros(len(E_list))
+    for iE, E in enumerate(E_list):
+        z = E + 1j * eta
+        sigL, sigR, gamL, gamR = _lead_sigmas(
+            E, lead_H00, lead_H01, lead_S00, lead_S01, eta)
+        A = np.zeros((ntot, ntot), dtype=complex)
+        for i in range(N):
+            Si = layers_S[i]
+            blk = (z * (np.eye(sizes[i]) if Si is None else Si)
+                   - layers_H[i])
+            A[offs[i]:offs[i + 1], offs[i]:offs[i + 1]] = blk
+            if i < N - 1:
+                Sc = coup_S[i]
+                tau = (z * (np.zeros_like(coup_H[i]) if Sc is None else Sc)
+                       - coup_H[i])
+                A[offs[i]:offs[i + 1], offs[i + 1]:offs[i + 2]] = tau
+                A[offs[i + 1]:offs[i + 2], offs[i]:offs[i + 1]] = \
+                    tau.conj().T
+        A[offs[0]:offs[1], offs[0]:offs[1]] -= sigL
+        A[offs[N - 1]:offs[N], offs[N - 1]:offs[N]] -= sigR
+        G = np.linalg.inv(A)
+        G1N = G[offs[N - 1]:offs[N], offs[0]:offs[1]]
+        T[iE] = float(np.real(np.trace(
+            gamR @ G1N @ gamL @ G1N.conj().T)))
+    return T

hamop/spectrum.py

@@ -0,0 +1,100 @@
+"""Band structures, densities of states and band fillings.
+
+Everything here diagonalizes the same Bloch matrices the Kubo module
+uses, through the same canonically orthogonalized solver, so spectral
+and optical statements about one model can never disagree about what
+the eigenvalues are.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from .eigsolve import gen_eigh
+
+__all__ = ["bands", "dos", "fermi_level", "band_edges"]
+
+KB = 8.617333262e-5  # Boltzmann constant, eV / K (CODATA 2018)
+
+
+def _eigs(model, kpts, thresh):
+    out = []
+    for k in kpts:
+        H, S = model.bloch(k)
+        out.append(gen_eigh(H, S, thresh=thresh))
+    return np.array(out)
+
+
+def bands(model, kpts, thresh=1e-10):
+    """Eigenvalues along a list of Cartesian k-points; shape (nk, nao)."""
+    return _eigs(model, kpts, thresh)
+
+
+def dos(model, energies, mesh=None, kpts=None, weights=None, eta=0.05,
+        thresh=1e-10):
+    """Gaussian-broadened density of states per unit cell (states / eV).
+
+    Either ``mesh`` (a Monkhorst-Pack grid) or explicit ``kpts`` with
+    ``weights`` summing to one.  Spin degeneracy is *not* included; the
+    integral over all energies equals the number of orbitals kept per
+    cell.
+    """
+    kpts, weights = _grid(model, mesh, kpts, weights)
+    rho = np.zeros_like(np.asarray(energies, dtype=float))
+    for k, w in zip(kpts, weights):
+        H, S = model.bloch(k)
+        e = gen_eigh(H, S, thresh=thresh)
+        for ei in e:
+            rho += w * np.exp(-0.5 * ((energies - ei) / eta) ** 2) \
+                / (eta * np.sqrt(2.0 * np.pi))
+    return rho
+
+
+def fermi_level(model, filling, mesh=None, kpts=None, weights=None,
+                T=300.0, thresh=1e-10, tol=1e-10):
+    """Chemical potential at which the mean band occupation per cell
+    equals ``filling`` (states per cell, spin not included), by
+    bisection on the Fermi-Dirac-weighted eigenvalue count."""
+    kpts, weights = _grid(model, mesh, kpts, weights)
+    eigs = _eigs(model, kpts, thresh)
+
+    def count(mu):
+        x = np.clip((eigs - mu) / (KB * T), -60.0, 60.0)
+        f = 1.0 / (1.0 + np.exp(x))
+        return float((f * np.asarray(weights)[:, None]).sum())
+
+    lo, hi = eigs.min() - 5.0, eigs.max() + 5.0
+    if not (count(lo) <= filling <= count(hi)):
+        raise ValueError("filling outside the reachable range")
+    for _ in range(200):
+        mid = 0.5 * (lo + hi)
+        if count(mid) < filling:
+            lo = mid
+        else:
+            hi = mid
+        if hi - lo < tol:
+            break
+    return 0.5 * (lo + hi)
+
+
+def band_edges(model, mu, mesh=None, kpts=None, weights=None, thresh=1e-10):
+    """(valence-band maximum, conduction-band minimum, gap) about mu."""
+    kpts, weights = _grid(model, mesh, kpts, weights)
+    eigs = _eigs(model, kpts, thresh)
+    below = eigs[eigs <= mu]
+    above = eigs[eigs > mu]
+    if below.size == 0 or above.size == 0:
+        raise ValueError("mu lies outside the spectrum")
+    vbm, cbm = float(below.max()), float(above.min())
+    return vbm, cbm, cbm - vbm
+
+
+def _grid(model, mesh, kpts, weights):
+    if mesh is not None:
+        return model.monkhorst_pack(mesh)
+    if kpts is None:
+        if model.cell is not None:
+            raise ValueError("periodic model: give mesh or kpts")
+        return [None], [1.0]
+    if weights is None:
+        weights = np.full(len(kpts), 1.0 / len(kpts))
+    return kpts, weights

hamop-0.1.0.dist-info/METADATA

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: hamop
+Version: 0.1.0
+Summary: One tight-binding Hamiltonian, every observable: bands, DOS, Kubo optical conductivity and NEGF transmission from the same real-space blocks, nonorthogonal bases included
+Author-email: "Tanvir M. Mahim" <tanvir.mahim@bracu.ac.bd>
+License: Apache-2.0
+Project-URL: Homepage, https://tanvir-mahmud-mahim.github.io/software/
+Project-URL: Repository, https://github.com/TaN-MM-Org/hamop
+Project-URL: Issues, https://github.com/TaN-MM-Org/hamop/issues
+Project-URL: Changelog, https://github.com/TaN-MM-Org/hamop/releases
+Keywords: tight binding,Kubo-Greenwood,NEGF,Landauer,optical conductivity,quantum transport,LCAO
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.22
+Requires-Dist: scipy>=1.8
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# hamop
+
+[![Tests](https://github.com/TaN-MM-Org/hamop/actions/workflows/ci.yml/badge.svg)](https://github.com/TaN-MM-Org/hamop/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/hamop?label=PyPI&color=blue)](https://pypi.org/project/hamop/)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
+
+**One tight-binding Hamiltonian, every observable, strictly
+consistent.** Build a Hamiltonian once, as real-space blocks in an
+orthogonal or nonorthogonal basis, and compute its band structure,
+density of states, Kubo-Greenwood optical conductivity and Landauer
+(NEGF) transmission from the same matrices.
+
+The point of the package is the consistency, not any single solver.
+When the optics of a model and its spectrum are computed by different
+codes with different conventions, they drift: a different gauge for the
+velocity operator, a different treatment of the overlap matrix, a
+different broadening, and suddenly the absorption edge no longer sits
+at the band gap. Here every observable diagonalizes the same Bloch
+matrices through the same canonically orthogonalized solver, and the
+Kubo velocity operator is built from the exact k-derivative of the same
+assembly, so spectral, optical and transport statements about one model
+cannot disagree with each other.
+
+## What it does
+
+- **`TightBindingModel`**: sites with any number of orbitals, directed
+  hopping blocks with automatic Hermitian completion, optional overlap
+  blocks (LCAO-style nonorthogonal bases), periodic in any dimension or
+  finite. Assembles H(k), S(k) and their exact k-derivatives in the
+  atomic gauge.
+- **Spectrum** (`bands`, `dos`, `fermi_level`, `band_edges`): band
+  structures along arbitrary k-lists, Gaussian-broadened densities of
+  states, chemical potential at a given filling by bisection, band
+  edges and gap about a chemical potential.
+- **Optics** (`sigma_optical`): Kubo-Greenwood real sheet conductivity
+  in units of e²/(4ℏ), with the nonorthogonal velocity correction
+  `v = dH/dk − (eₙ+eₘ)/2 dS/dk` that makes the result exactly
+  invariant under a shift of the energy zero.
+- **Transport** (`sancho_rubio`, `transmission`,
+  `transmission_direct`): two-probe Landauer transmission with
+  Sancho-Rubio lead surface Green functions and a recursive Green
+  function sweep, nonorthogonal bases included, plus a dense
+  direct-inversion reference implementation of the same quantity.
+- **`gen_eigh`**: generalized eigensolver with canonical
+  orthogonalization (Szabo and Ostlund, *Modern Quantum Chemistry*,
+  sec. 3.4.5), so mildly overcomplete overlaps cannot blow up the
+  spectrum — the standard remedy used inside electronic-structure
+  codes.
+
+Dependencies: NumPy and SciPy. Nothing else.
+
+## Validation against closed forms
+
+Every physical claim in the package is pinned by a test against an
+exact result, not a stored number:
+
+- the single-orbital chain reproduces E(k) = e₀ + 2t cos ka to machine
+  precision, and its nonorthogonal variant reproduces
+  E(k) = 2t cos ka / (1 + 2s cos ka);
+- the chain density of states matches 1/(π√(4t² − E²)) and integrates
+  to the orbital count;
+- graphene's nearest-neighbour model gives Dirac-point closure at K
+  exactly, ±3|t| at Γ exactly, and the **universal optical sheet
+  conductivity e²/(4ℏ)** on the interband plateau (Kuzmenko et al.,
+  Phys. Rev. Lett. 100, 117401 (2008)) — which is also the absolute
+  anchor for the package's conductivity unit;
+- the two-site molecule absorbs at exactly 2|t| with the hand-derived
+  velocity matrix element |M| = |a t|;
+- σ(ω) is invariant to 10⁻¹⁰ under H → H + cS with μ → μ + c, which
+  pins the nonorthogonal velocity term;
+- the chain's lead surface Green function matches its closed form
+  (E − i√(4t² − E²))/(2t²); a pristine chain transmits exactly one
+  channel inside the band and nothing outside; two decoupled chains
+  transmit two; an on-site impurity ε reproduces
+  T = (4t² − E²)/((4t² − E²) + ε²);
+- the recursive Green function sweep agrees with dense direct inversion
+  to machine precision, disorder and overlap included.
+
+Run them yourself: `pip install -e .[test]` then `pytest`.
+
+## Install and use
+
+```
+pip install hamop
+```
+
+```python
+import numpy as np
+from hamop import graphene, bands, dos, sigma_optical
+
+g = graphene(t=-2.7, a=2.46)          # eV, Angstrom
+omega = np.linspace(0.5, 2.0, 60)
+sigma = sigma_optical(g, omega, mu=0.0, mesh=120, eta=0.12)
+# sigma is ~1.0 on the plateau: the universal e^2/(4 hbar)
+```
+
+Building your own model:
+
+```python
+from hamop import TightBindingModel, band_edges
+
+m = TightBindingModel(positions=[[0.0], [0.7]], norb=1, cell=[[2.0]])
+m.add_hop(0, 1, (0,), [[-1.0]])       # intra-cell bond
+m.add_hop(1, 0, (1,), [[-0.6]])       # inter-cell bond
+print(band_edges(m, mu=0.0, mesh=2001))   # the SSH gap, 2|t1 - t2|
+```
+
+Conventions, stated once: energies in eV, positions in Angstrom, k in
+1/Angstrom, Cartesian. Each directed hopping block is added once and
+its Hermitian partner is implied. Optical conductivity is the real
+sheet conductivity in units of e²/(4ℏ) with spin degeneracy as an
+explicit factor (default 2). The velocity operator uses the standard
+atomistic position gauge (position operator diagonal at the sites);
+the intra-atomic dipole contribution is neglected, the common
+approximation in tight-binding optics.
+
+## Relation to existing tools
+
+Excellent tools cover parts of this space: [PythTB](https://www.physics.rutgers.edu/pythtb/) and [pybinding](https://docs.pybinding.site/) build tight-binding models and their spectra, and [Kwant](https://kwant-project.org/) is the standard for quantum transport. hamop does not replace any of them, and for their core use cases they are more capable. Its niche is the combination they leave open: nonorthogonal (LCAO-style) overlap matrices as first-class citizens across *all* observables, optics and transport computed from the same Bloch assembly as the spectrum so the three can never disagree, and a deliberately small NumPy/SciPy-only core validated line by line against closed forms -- the shape of engine an LCAO electronic-structure pipeline exports its Hamiltonians into.
+
+## Status
+
+v0.1.0 (alpha). Implemented and tested: the model container with exact
+k-derivatives, canonical-orthogonalization eigensolver, band
+structures, densities of states, filling-resolved chemical potentials,
+band edges, Kubo-Greenwood optical conductivity for periodic and finite
+systems, Sancho-Rubio surface Green functions, and recursive plus
+direct-inversion Landauer transmission.
+
+Not yet implemented, stated plainly: k-space symmetry reduction (grids
+are full Monkhorst-Pack), Lorentzian and adaptive broadenings, the
+Drude (intraband) term of the conductivity, spin-orbit-coupled blocks
+as a first-class convention (complex blocks work, but no helper),
+Hall/off-diagonal conductivity tensors, and interaction self-energies
+in the transport module. Sparse or very large models are out of scope
+for now: matrices are dense.
+
+## Where it comes from
+
+Methodological basis:
+
+> "Learning the quantum Hamiltonian of defective monolayer MoS2
+> reveals collective vacancy brightness decoupled from defect count";
+> code for the paper:
+> https://github.com/Tanvir-Mahmud-Mahim/mos2-vacancy-optics
+
+That study computes the optics, the electronic structure and the
+transport of vacancy-disordered MoS2 supercells from one
+density-functional Hamiltonian, so that a defect configuration's
+optical and electronic signatures are strictly consistent — and its
+conclusions depend on that consistency. This package is the
+general-purpose engine distilled from that pipeline: the same
+observables for any Hamiltonian a user supplies, with the
+material-specific machinery (DFT extraction, machine-learned
+Hamiltonians, MoS2 structures) left in the paper repository.
+
+## Support and governance
+
+The package is written and maintained by Tanvir Mahmud Mahim
+(Department of Electrical and Electronic Engineering, BRAC University),
+who reviews every change and takes the final decision on scope and
+releases. There is no separate governance body; design questions are
+discussed in the open in issues and pull requests, and the standing
+rule of [CONTRIBUTING.md](CONTRIBUTING.md) binds the maintainer exactly
+as it binds contributors: a change that touches physics arrives with a
+test, and a constant arrives with its source.
+
+Support runs through the issue tracker at
+https://github.com/TaN-MM-Org/hamop/issues. Usage questions are welcome
+there alongside bug reports; a docstring that left a unit or a sign
+convention unclear is treated as a documentation bug, not as user
+error. The maintainer aims to respond within a week.
+
+While the version is below 1.0 the API may still move between minor
+versions; such changes are called out in the release notes. The
+limitations named under Status are deliberate scope, recorded there
+precisely so that a user can tell a designed-out feature from an
+oversight.
+
+## License
+
+Apache-2.0 (see [LICENSE](LICENSE)). Citation metadata is in
+[CITATION.cff](CITATION.cff).

hamop-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+hamop/__init__.py,sha256=L25YfOtHTmhBgQOuz_TPHXEFr65SpN7VeGXJvo9XxGw,1301
+hamop/eigsolve.py,sha256=MX100E8gvG-pz9EAt-nxm3nPxk4a860-QvjN-j8PX-4,1541
+hamop/kubo.py,sha256=1JfYzvedPZ1M_0MaR33ARAb4pTin485XwjjlHVbmIMo,3985
+hamop/lattices.py,sha256=U8Xhhc6nTTzW6TEjZUnIFBW7vu9k1tzYeuhnubSoLMw,2415
+hamop/model.py,sha256=xaCb_jlRi4Zl7tW_z4wh6BF7ChPK-aEQPCkUOSHbWG8,9023
+hamop/negf.py,sha256=x5vCAnXq5lCeakOf_XCMvZbQmVOM-OPFq9h2BJfieTU,6627
+hamop/spectrum.py,sha256=cEZFa1ow4-PJuTccaq-wqCdZkQ1vvIDyNzwkwWJZPQ8,3408
+hamop-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+hamop-0.1.0.dist-info/METADATA,sha256=QKKcIulDTshb5W880bzwrVe4fbk5fyh0gTlybzDq0Ns,10252
+hamop-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+hamop-0.1.0.dist-info/top_level.txt,sha256=_ByXtlSRP4hTvxZpTXKhlPrPUUr4EOP7dApNrUxtrMw,6
+hamop-0.1.0.dist-info/RECORD,,

hamop-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hamop-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

hamop-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+hamop