update noise: allow to use reflection, disallow Green's functions

kwant/physics/noise.py

@@ -10,20 +10,27 @@ import numpy as np
 
 def two_terminal_shotnoise(smatrix):
     """Compute the shot-noise in a two-terminal setup.
-    [Given by tr((1 - t*t^\dagger) * t*t^\dagger)]."""
+
+    In a two terminal system the shot noise is given by `tr((1 - t*t^\dagger) *
+    t*t^\dagger)`.
+
+    Parameters
+    ----------
+    smatrix : `~kwant.solvers.common.BlockResult` instance
+        A two terminal scattering matrix.
+
+    Returns
+    -------
+    noise : float
+        Shot noise measured in noise quanta `2 e^3 |V| / pi hbar`.
+    """
 
     if len(smatrix.lead_info) != 2:
         raise ValueError("Only works for two-terminal systems!")
 
-    if 1 in smatrix.out_leads and 0 in smatrix.in_leads:
-        ttdag = smatrix._a_ttdagger_a_inv(1, 0)
-    if 0 in smatrix.out_leads and 1 in smatrix.in_leads:
-        ttdag = smatrix._a_ttdagger_a_inv(0, 1)
-    else:
-        raise ValueError("Need S-matrix block for transmission!")
-
-    ttdag -= np.dot(ttdag, ttdag)
-    return np.trace(ttdag).real
+    t = smatrix.submatrix(smatrix.out_leads[0], smatrix.in_leads[0])
+    ttdag = np.dot(t, t.conj().T)
+    return np.trace(ttdag - np.dot(ttdag, ttdag)).real
 
 
 # A general multi-terminal routine for noise would need to also have the

kwant/physics/tests/test_noise.py

@@ -15,7 +15,7 @@ from kwant.physics.noise import two_terminal_shotnoise
 n = 5
 chain = kwant.lattice.chain()
 
-def _twoterminal_system():
+def twoterminal_system():
     np.random.seed(11)
     system = kwant.Builder()
     lead = kwant.Builder(kwant.TranslationalSymmetry((1,)))
@@ -28,30 +28,22 @@ def _twoterminal_system():
     lead[chain(0), chain(1)] = t
     system.attach_lead(lead)
     system.attach_lead(lead.reversed())
-    return system.finalized()
+    return system
 
 
-def test_twoterminal_input():
+def test_multiterminal_input():
     """Input checks for two_terminal_shotnoise"""
 
-    fsys = _twoterminal_system()
-    sol = kwant.solve(fsys, out_leads=[0], in_leads=[0])
+    sys = twoterminal_system()
+    sys.attach_lead(sys.leads[0].builder)
+    sol = kwant.solve(sys.finalized(), out_leads=[0], in_leads=[0])
     assert_raises(ValueError, two_terminal_shotnoise, sol)
 
 
-class LeadWithOnlySelfEnergy(object):
-    def __init__(self, lead):
-        self.lead = lead
-
-    def selfenergy(self, energy, args=()):
-        assert args == ()
-        return self.lead.selfenergy(energy)
-
-
 def test_twoterminal():
     """Shot noise in a two-terminal conductor"""
 
-    fsys = _twoterminal_system()
+    fsys = twoterminal_system().finalized()
 
     sol = kwant.solve(fsys)
     t = sol.submatrix(1, 0)
@@ -59,12 +51,3 @@ def test_twoterminal():
     noise_should_be = np.sum(Tn * (1 - Tn))
 
     assert_almost_equal(noise_should_be, two_terminal_shotnoise(sol))
-
-    # replace leads successively with self-energy
-    fsys.leads[0] = LeadWithOnlySelfEnergy(fsys.leads[0])
-    sol = kwant.solve(fsys)
-    assert_almost_equal(noise_should_be, two_terminal_shotnoise(sol))
-
-    fsys.leads[1] = LeadWithOnlySelfEnergy(fsys.leads[1])
-    sol = kwant.solve(fsys)
-    assert_almost_equal(noise_should_be, two_terminal_shotnoise(sol))