def test_complex_multiorbital_hamiltonian(): def checkerboard_lattice(delta, t): lat = pb.Lattice(a1=[1, 0], a2=[0, 1]) lat.add_sublattices(('A', [0, 0], -delta), ('B', [1 / 2, 1 / 2], delta)) lat.add_hoppings( ([0, 0], 'A', 'B', t), ([0, -1], 'A', 'B', t), ([-1, 0], 'A', 'B', t), ([-1, -1], 'A', 'B', t), ) return lat hopp_t = np.array([[2 + 2j, 3 + 3j], [4 + 4j, 5 + 5j]]) # multi-orbital hopping onsite_en = np.array([[1, 1j], [-1j, 1]]) # onsite energy model = pb.Model(checkerboard_lattice(onsite_en, hopp_t), pb.translational_symmetry(True, True)) h = model.hamiltonian.toarray() assert model.system.num_sites == 2 assert h.shape[0] == 4 assert pytest.fuzzy_equal(h, h.T.conjugate()) # check if Hermitian assert pytest.fuzzy_equal( h[:2, :2], -h[-2:, -2:]) # onsite energy on A and B is opposite assert pytest.fuzzy_equal(h[:2, 2:4], 4 * hopp_t) # hopping A <-> B is 4 * hopp_t
def assert_state(name, **kwargs): state, x, y, z, nearest = capture[name] assert state.shape == kwargs["shape"] assert pytest.fuzzy_equal(state, kwargs["state"]) assert x.shape == kwargs["shape"] assert pytest.fuzzy_equal(x, kwargs["x"]) assert pytest.fuzzy_equal(y, kwargs["y"]) assert pytest.fuzzy_equal(z, kwargs["z"]) assert np.all(nearest == kwargs["nearest"])
def assert_positions(name, **kwargs): x, y, z, nearest = capture[name] assert x.shape == kwargs["shape"] assert y.shape == kwargs["shape"] assert z.shape == kwargs["shape"] assert pytest.fuzzy_equal(x, kwargs["x"]) assert pytest.fuzzy_equal(y, kwargs["y"]) assert pytest.fuzzy_equal(z, kwargs["z"]) assert np.all(nearest == kwargs["nearest"])
def test_builder(): """Builder pattern methods""" lattice = pb.Lattice([1, 0], [0, 1]) copy = lattice.with_offset([0, 0.5]) assert pytest.fuzzy_equal(copy.offset, [0, 0.5, 0]) assert pytest.fuzzy_equal(lattice.offset, [0, 0, 0]) copy = lattice.with_min_neighbors(5) assert copy.min_neighbors == 5 assert lattice.min_neighbors == 1
def assert_onsite(name, **expected): energy, x, y, z = capture[name] assert energy.shape == expected["shape"] expected_energy = np.array(expected["energy"]) for index in np.ndindex(*expected_energy.shape): expected_slice = np.full(energy.shape[-1], expected_energy[index]) assert pytest.fuzzy_equal(energy[index], expected_slice) assert pytest.fuzzy_equal(x, expected["x"]) assert pytest.fuzzy_equal(y, expected["y"]) assert pytest.fuzzy_equal(z, expected["z"])
def test_ldos(kpm, baseline, plot_if_fails): energy = np.linspace(0, 2, 25) results = [k.calc_ldos(energy, broadening=0.15, position=(0, 0)) for k in kpm] expected = pb.results.LDOS(energy, baseline(results[0].ldos.astype(np.float32))) for i in range(len(results)): plot_if_fails(results[i], expected, 'plot', label=i) assert pytest.fuzzy_equal(results[0], expected, rtol=1e-4, atol=1e-6) assert pytest.fuzzy_equal(results[1], expected, rtol=1e-4, atol=1e-6) assert pytest.fuzzy_equal(results[2], expected, rtol=1e-4, atol=1e-6) assert pytest.fuzzy_equal(results[3], expected, rtol=1e-4, atol=1e-6)
def test_site_position(): @pb.site_position_modifier def mod(x, y, z): return x + 1, y + 1, z + 1 assert (one, ) * 3 == mod(zero, zero, zero) assert (one, ) * 3 == mod.apply(zero, zero, zero, one) capture = {} @pb.site_position_modifier def check_args(x, y, z, sub_id, sites): capture[sub_id] = [v.copy() for v in (x, y, z)] capture[sub_id].append(sites.argsort_nearest([0, graphene.a_cc / 2])) return x, y, z def assert_positions(name, **kwargs): x, y, z, nearest = capture[name] assert x.shape == kwargs["shape"] assert y.shape == kwargs["shape"] assert z.shape == kwargs["shape"] assert pytest.fuzzy_equal(x, kwargs["x"]) assert pytest.fuzzy_equal(y, kwargs["y"]) assert pytest.fuzzy_equal(z, kwargs["z"]) assert np.all(nearest == kwargs["nearest"]) model = build_model(check_args, pb.primitive(1, 2)) assert model.hamiltonian.dtype == np.float32 assert_positions("A", shape=(2, ), nearest=[1, 0], x=[-graphene.a / 2, 0], y=[-2 * graphene.a_cc, -graphene.a_cc / 2], z=[0, 0]) assert_positions("B", shape=(2, ), nearest=[1, 0], x=[-graphene.a / 2, 0], y=[-graphene.a_cc, graphene.a_cc / 2], z=[0, 0]) @pb.site_position_modifier def shift(x, y, z): return x + 1, y + 1, z + 1 model = build_model(check_args, shift) assert pytest.fuzzy_equal(model.system.x, [1, 1]) assert pytest.fuzzy_equal(model.system.y, [1 - graphene.a_cc / 2, 1 + graphene.a_cc / 2]) assert pytest.fuzzy_equal(model.system.z, [1, 1])
def test_lapack(baseline, plot_if_fails): model = pb.Model(graphene.monolayer(), pb.translational_symmetry()) solver = pb.solver.lapack(model) assert pytest.fuzzy_equal(solver.eigenvalues, [-3*abs(graphene.t), 3*abs(graphene.t)]) from math import pi, sqrt g = [0, 0] k1 = [-4*pi / (3*sqrt(3) * graphene.a_cc), 0] m = [0, 2*pi / (3 * graphene.a_cc)] k2 = [2*pi / (3*sqrt(3) * graphene.a_cc), 2*pi / (3 * graphene.a_cc)] bands = solver.calc_bands(k1, g, m, k2, step=3) expected = baseline(bands) plot_if_fails(bands, expected, 'plot') assert pytest.fuzzy_equal(bands, expected, 2.e-2, 1.e-6)
def test_ldos(kpm, baseline, plot_if_fails): energy = np.linspace(0, 2, 25) results = [ k.calc_ldos(energy, broadening=0.15, position=(0, 0)) for k in kpm ] expected = pb.results.LDOS(energy, baseline(results[0].ldos.astype(np.float32))) for i in range(len(results)): plot_if_fails(results[i], expected, 'plot', label=i) assert pytest.fuzzy_equal(results[0], expected, rtol=1e-4, atol=1e-6) assert pytest.fuzzy_equal(results[1], expected, rtol=1e-4, atol=1e-6) assert pytest.fuzzy_equal(results[2], expected, rtol=1e-4, atol=1e-6) assert pytest.fuzzy_equal(results[3], expected, rtol=1e-4, atol=1e-6)
def test_structure_map(model): system = model.system zeros = np.zeros_like(system.x) spatial_map = pb.results.SpatialMap(zeros, system.positions, system.sublattices) structure_map = system.with_data(zeros) assert pytest.fuzzy_equal(spatial_map.data, structure_map.spatial_map.data) assert pytest.fuzzy_equal(spatial_map.positions, structure_map.spatial_map.positions) assert pytest.fuzzy_equal(spatial_map.sublattices, structure_map.spatial_map.sublattices) tmp = structure_map[structure_map.x < 0.05] assert structure_map.hoppings.nnz == 41 assert tmp.hoppings.nnz == 21 assert tmp.hoppings.tocsr().data.mapping == model.lattice.impl.hop_name_map
def test_site_generator(): """Generated some disordered sites""" @pb.site_generator("New", energy=0.4) def site_gen(): x = [10, 20, 30] y = [1, 2, 3] z = [0, -1, -2] return x, y, z model = pb.Model(graphene.monolayer(), graphene.hexagon_ac(1), site_gen) s = model.system[model.system.x >= 10] assert s.num_sites == 3 assert pytest.fuzzy_equal(s.x, [10, 20, 30]) assert pytest.fuzzy_equal(s.y, [1, 2, 3]) assert pytest.fuzzy_equal(s.z, [0, -1, -2])
def test_expected(lattice, baseline, plot_if_fails): expected = baseline(lattice) plot_if_fails(lattice, expected, 'plot') assert lattice.sub_name_map == expected.sub_name_map assert lattice.hop_name_map == expected.hop_name_map assert pytest.fuzzy_equal(lattice, expected)
def test_dos(params, baseline, plot_if_fails): configurations = [ { 'matrix_format': "ELL", 'optimal_size': False, 'interleaved': False }, { 'matrix_format': "ELL", 'optimal_size': True, 'interleaved': True }, ] model = pb.Model(*params) kernel = pb.lorentz_kernel() strategies = [ pb.kpm(model, kernel=kernel, silent=True, **c) for c in configurations ] energy = np.linspace(0, 2, 25) results = [kpm.calc_dos(energy, broadening=0.15) for kpm in strategies] expected = results[0].with_data( baseline(results[0].data.astype(np.float32))) for i in range(len(results)): plot_if_fails(results[i], expected, 'plot', label=i) for result in results: assert pytest.fuzzy_equal(result, expected, rtol=1e-3, atol=1e-6)
def test_brillouin_zone(): from math import pi, sqrt lat = pb.Lattice(a1=1) assert pytest.fuzzy_equal(lat.brillouin_zone(), [-pi, pi]) lat = pb.Lattice(a1=[0, 1], a2=[0.5, 0.5]) assert pytest.fuzzy_equal( lat.brillouin_zone(), [[0, -2 * pi], [2 * pi, 0], [0, 2 * pi], [-2 * pi, 0]]) # Identical lattices represented using acute and obtuse angles between primitive vectors acute = pb.Lattice(a1=[1, 0], a2=[1 / 2, 1 / 2 * sqrt(3)]) obtuse = pb.Lattice(a1=[1 / 2, 1 / 2 * sqrt(3)], a2=[1 / 2, -1 / 2 * sqrt(3)]) assert pytest.fuzzy_equal(acute.brillouin_zone(), obtuse.brillouin_zone())
def test_hopping_generator(): """Generated next-nearest hoppings should produce the same result as the builtin lattice""" from scipy.spatial import cKDTree @pb.hopping_generator("tnn_test", energy=graphene.t_nn) def next_nearest(x, y, z): pos = np.stack([x, y, z], axis=1) dmin = graphene.a * 0.95 dmax = graphene.a * 1.05 kdtree = cKDTree(pos) coo = kdtree.sparse_distance_matrix(kdtree, dmax).tocoo() idx = coo.data > dmin return coo.row[idx], coo.col[idx] @pb.onsite_energy_modifier def onsite_offset(energy): return energy + 3 * graphene.t_nn model = pb.Model(graphene.monolayer(), next_nearest, onsite_offset, graphene.hexagon_ac(1)) expected = pb.Model(graphene.monolayer(2), graphene.hexagon_ac(1)) assert pytest.fuzzy_equal(model.hamiltonian, expected.hamiltonian) @pb.hopping_generator("t_new", energy=1.0) def bad_generator(): """Different array lengths""" return [0, 1, 2], [0, 1] model = pb.Model(graphene.monolayer(), pb.primitive(3, 3), bad_generator) with pytest.raises(RuntimeError) as excinfo: model.eval() assert "the number of `from` and `to` indices must be equal" in str( excinfo.value)
def test_ldos_sublattice(): """LDOS for A and B sublattices should be antisymmetric for graphene with a mass term""" model = pb.Model(graphene.monolayer(), graphene.hexagon_ac(10), graphene.mass_term(1)) kpm = pb.greens.kpm(model) a, b = (kpm.calc_ldos(np.linspace(-5, 5, 50), 0.1, [0, 0], sub) for sub in ('A', 'B')) assert pytest.fuzzy_equal(a.ldos, b.ldos[::-1], rtol=1e-3, atol=1e-6)
def test_ldos_sublattice(): """LDOS for A and B sublattices should be antisymmetric for graphene with a mass term""" model = pb.Model(graphene.monolayer(), graphene.hexagon_ac(10), graphene.mass_term(1)) kpm = pb.chebyshev.kpm(model) a, b = (kpm.calc_ldos(np.linspace(-5, 5, 50), 0.1, [0, 0], sub) for sub in ('A', 'B')) assert pytest.fuzzy_equal(a.ldos, b.ldos[::-1], rtol=1e-3, atol=1e-6)
def test_pickle_round_trip(lattice, tmpdir): file_name = str(tmpdir.join('file.npz')) pb.save(lattice, file_name) from_file = pb.load(file_name) assert lattice.sub_name_map == from_file.sub_name_map assert lattice.hop_name_map == from_file.hop_name_map assert pytest.fuzzy_equal(lattice, from_file)
def test_dos(solver, baseline, plot_if_fails): energy = np.linspace(0, 0.075, 15) result = solver.calc_dos(energy, 0.01) expected = pb.results.DOS(energy, baseline(result.dos)) plot_if_fails(result, expected, 'plot') assert pytest.fuzzy_equal(result, expected, rtol=2e-2, atol=1e-5)
def test_add_multiorbital_sublattice(): lat = pb.Lattice([1, 0], [0, 1]) lat.add_one_sublattice("A", [0, 0]) assert lat.nsub == 1 lat.add_one_sublattice("B", [0, 0], [1, 2, 3]) assert pytest.fuzzy_equal(lat.sublattices["B"].energy, [[1, 0, 0], [0, 2, 0], [0, 0, 3]]) lat.add_one_sublattice("C", [0, 0], [[1, 2, 3], [0, 4, 5], [0, 0, 6]]) assert pytest.fuzzy_equal(lat.sublattices["C"].energy, [[1, 2, 3], [2, 4, 5], [3, 5, 6]]) lat.add_one_sublattice("D", [0, 0], [[1, 2j, 3], [0, 4, 5j], [0, 0, 6]]) assert pytest.fuzzy_equal(lat.sublattices["D"].energy, [[1, 2j, 3], [-2j, 4, 5j], [3, -5j, 6]]) lat.add_one_sublattice("E", [0, 0], [[1, 2, 3], [2, 4, 5], [3, 5, 6]]) assert pytest.fuzzy_equal(lat.sublattices["E"].energy, [[1, 2, 3], [2, 4, 5], [3, 5, 6]]) assert lat.nsub == 5 with pytest.raises(RuntimeError) as excinfo: lat.add_one_sublattice("zero-dimensional", [0, 0], []) assert "can't be zero-dimensional" in str(excinfo.value) with pytest.raises(RuntimeError) as excinfo: lat.add_one_sublattice("complex onsite energy", [0, 0], [1j, 2j, 3j]) assert "must be a real vector or a square matrix" in str(excinfo.value) with pytest.raises(RuntimeError) as excinfo: lat.add_one_sublattice("not square", [0, 0], [[1, 2, 3], [4, 5, 6]]) assert "must be a real vector or a square matrix" in str(excinfo.value) with pytest.raises(RuntimeError) as excinfo: lat.add_one_sublattice("not square", [0, 0], [[1j, 2, 3], [2, 4j, 5], [3, 5, 6j]]) assert "The main diagonal of the onsite hopping term must be real" in str( excinfo.value) with pytest.raises(RuntimeError) as excinfo: lat.add_one_sublattice("not Hermitian", [0, 0], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]) assert "The onsite hopping matrix must be upper triangular or Hermitian" in str( excinfo.value)
def test_expected(model, baseline): model.attach_lead(1, [0, -1], [0, 1]) model.attach_lead(-1, [0, -1], [0, 1]) model.attach_lead(2, [-1, -5], [1, -5]) model.attach_lead(-2, [-1, 5], [1, 5]) ports = model.system.ports expected = baseline(ports) assert pytest.fuzzy_equal(ports, expected, 1.e-4, 1.e-6)
def test_kwant(): """Create the same model using kwant and pybinding and solve with kwant.smatrix""" energy = 1 vs = np.linspace(-2, 0, 5) system = make_wire_with_flat_potential() kwant_result = np.array([calc_transmission(system, energy, v) for v in vs]) pb_result = np.array([calc_transmission(pb_model(v).tokwant(), energy) for v in vs]) assert pytest.fuzzy_equal(pb_result, kwant_result)
def test_freeform(baseline, plot_if_fails): def donut(inner_radius, outer_radius): def contains(x, y, _): r = np.sqrt(x**2 + y**2) return np.logical_and(inner_radius < r, r < outer_radius) return pb.FreeformShape(contains, width=[2 * outer_radius, 2 * outer_radius]) assert pytest.fuzzy_equal( donut(0.5, 1).vertices, [[-1, -1, 0], [1, -1, 0], [-1, 1, 0], [1, 1, 0]] * 2) shape = donut(0.6, 1.1) model = pb.Model(graphene.monolayer(), shape) expected = baseline(model.system) plot_if_fails(model.system, expected, 'plot') plot_if_fails(shape, shape, 'plot') assert pytest.fuzzy_equal(model.system, expected, 1.e-4, 1.e-6)
def test_hamiltonian(model): """Must be in the correct format and point to memory allocated in C++ (no copies)""" h = model.hamiltonian assert isinstance(h, csr_matrix) assert h.dtype == np.float32 assert h.shape == (2, 2) assert pytest.fuzzy_equal(h.data, [graphene.t] * 2) assert pytest.fuzzy_equal(h.indices, [1, 0]) assert pytest.fuzzy_equal(h.indptr, [0, 1, 2]) assert h.data.flags['OWNDATA'] is False assert h.data.flags['WRITEABLE'] is False with pytest.raises(ValueError) as excinfo: h.data += 1 assert "read-only" in str(excinfo.value) h2 = model.hamiltonian assert h2.data is not h.data assert point_to_same_memory(h2.data, h.data)
def test_kpm_reuse(): """KPM should return the same result when a single object is used for multiple calculations""" model = pb.Model(graphene.monolayer(), graphene.hexagon_ac(10)) kpm = pb.chebyshev.kpm(model) energy = np.linspace(-5, 5, 50) broadening = 0.1 for position in [0, 0], [6, 0]: actual = kpm.calc_ldos(energy, broadening, position) expected = pb.chebyshev.kpm(model).calc_ldos(energy, broadening, position) assert pytest.fuzzy_equal(actual, expected, rtol=1e-3, atol=1e-6)
def test_kpm_reuse(): """KPM should return the same result when a single object is used for multiple calculations""" model = pb.Model(graphene.monolayer(), graphene.hexagon_ac(10)) kpm = pb.greens.kpm(model) energy = np.linspace(-5, 5, 50) broadening = 0.1 for position in [0, 0], [6, 0]: actual = kpm.calc_ldos(energy, broadening, position) expected = pb.greens.kpm(model).calc_ldos(energy, broadening, position) assert pytest.fuzzy_equal(actual, expected, rtol=1e-3, atol=1e-6)
def test_freeform(baseline, plot_if_fails): def donut(inner_radius, outer_radius): def contains(x, y, _): r = np.sqrt(x**2 + y**2) return np.logical_and(inner_radius < r, r < outer_radius) return pb.FreeformShape(contains, width=[2 * outer_radius, 2 * outer_radius]) assert pytest.fuzzy_equal( donut(0.5, 1).vertices, [[ 1, 1, 0], [ 1, 1, 0], [ 1, -1, 0], [ 1, -1, 0], [-1, 1, 0], [-1, 1, 0], [-1, -1, 0], [-1, -1, 0]] ) shape = donut(0.6, 1.1) model = pb.Model(graphene.monolayer(), shape) expected = baseline(model.system) plot_if_fails(model.system, expected, 'plot') plot_if_fails(shape, shape, 'plot') assert pytest.fuzzy_equal(model.system, expected, 1.e-4, 1.e-6)
def test_spatial_ldos(solver, baseline, plot_if_fails): ldos_map = solver.calc_spatial_ldos(energy=0.05, broadening=0.01) x_max = solver.system.x.max() y_max = solver.system.y.max() ldos_map = ldos_map.cropped(x=(x_max - 1, x_max + 1), y=(y_max - 1, y_max + 1)) expected = ldos_map.with_data(baseline(ldos_map.data)) plot_if_fails(ldos_map, expected, "plot") assert pytest.fuzzy_equal(ldos_map, expected, rtol=1e-2, atol=1e-5)
def test_ldos(solver, plot_if_fails): """Compare an LDOS sum at every position with directly calculated DOS""" energy = np.linspace(0, 0.075, 15) broadening = 0.01 expected = solver.calc_dos(energy, broadening) ldos = np.stack([solver.calc_ldos(energy, broadening, position).ldos for position in zip(*solver.system.positions)]) result = pb.results.DOS(energy, np.sum(ldos, axis=0)) plot_if_fails(result, expected, 'plot') assert pytest.fuzzy_equal(result, expected)
def test_kwant(): """Create the same model using kwant and pybinding and solve with kwant.smatrix""" energy = 1 vs = np.linspace(-2, 0, 5) system = make_wire_with_flat_potential() kwant_result = np.array( [calc_transmission(system, energy, v) for v in vs]) pb_result = np.array( [calc_transmission(pb_model(v).tokwant(), energy) for v in vs]) assert pytest.fuzzy_equal(pb_result, kwant_result)
def test_add_sublattice(capsys): lat = pb.Lattice(1) assert lat.nsub == 0 lat.add_one_sublattice("A", 0.0) assert lat.nsub == 1 lat.add_sublattices(("B", 0.1), ("C", 0.2)) assert lat.nsub == 3 subs = lat.sublattices assert len(subs) == 3 assert all(v in subs for v in ("A", "B", "C")) assert pytest.fuzzy_equal(subs["A"].position, [0, 0, 0]) assert subs["A"].energy == 0 assert subs["A"].unique_id == 0 assert subs["A"].alias_id == 0 assert pytest.fuzzy_equal(subs["B"].position, [0.1, 0, 0]) assert subs["B"].energy == 0 assert subs["B"].unique_id == 1 assert subs["B"].alias_id == 1 assert pytest.fuzzy_equal(subs["C"].position, [0.2, 0, 0]) assert subs["C"].energy == 0 assert subs["C"].unique_id == 2 assert subs["C"].alias_id == 2 with pytest.raises(RuntimeError) as excinfo: lat.add_one_sublattice("", 0) assert "Sublattice name can't be blank" in str(excinfo.value) with pytest.raises(RuntimeError) as excinfo: lat.add_one_sublattice("A", 0) assert "Sublattice 'A' already exists" in str(excinfo.value) with pytest.warns(LoudDeprecationWarning): assert lat["A"] == "A" capsys.readouterr()
def test_structure_map(model): system = model.system zeros = np.zeros_like(system.x) spatial_map = pb.results.SpatialMap.from_system(zeros, system) structure_map = pb.results.StructureMap.from_system(zeros, system) assert pytest.fuzzy_equal(spatial_map, structure_map.spatial_map) tmp = structure_map[structure_map.x < 0.05] assert structure_map.hoppings.nnz == 41 assert tmp.hoppings.nnz == 21 assert tmp.hoppings.data.mapping == model.lattice.impl.hop_name_map
def test_structure_map(model): system = model.system zeros = np.zeros_like(system.positions.x) spatial_map = pb.results.SpatialMap.from_system(zeros, system) structure_map = pb.results.StructureMap.from_system(zeros, system) assert pytest.fuzzy_equal(spatial_map, structure_map.spatial_map) tmp = structure_map.copy() tmp.filter(tmp.pos.x < 0.05) assert structure_map.hoppings.nnz == 41 assert tmp.hoppings.nnz == 21
def test_add_sublattice(): lat = pb.Lattice(1) assert lat.nsub == 0 lat.add_one_sublattice("A", 0.0) assert lat.nsub == 1 lat.add_sublattices(("B", 0.1), ("C", 0.2)) assert lat.nsub == 3 subs = lat.sublattices assert len(subs) == 3 assert all(v in subs for v in ("A", "B", "C")) assert pytest.fuzzy_equal(subs["A"].position, [0, 0, 0]) assert subs["A"].energy == 0 assert subs["A"].unique_id == 0 assert subs["A"].alias_id == 0 assert pytest.fuzzy_equal(subs["B"].position, [0.1, 0, 0]) assert subs["B"].energy == 0 assert subs["B"].unique_id == 1 assert subs["B"].alias_id == 1 assert pytest.fuzzy_equal(subs["C"].position, [0.2, 0, 0]) assert subs["C"].energy == 0 assert subs["C"].unique_id == 2 assert subs["C"].alias_id == 2 with pytest.raises(RuntimeError) as excinfo: lat.add_one_sublattice("", 0) assert "Sublattice name can't be blank" in str(excinfo.value) with pytest.raises(RuntimeError) as excinfo: lat.add_one_sublattice("A", 0) assert "Sublattice 'A' already exists" in str(excinfo.value) pytest.deprecated_call(lat.__getitem__, "A")
def assert_positions(name, **expected): _, x1, y1, z1, x2, y2, z2 = capture[name] assert pytest.fuzzy_equal(x1.squeeze(), expected["x1"]) assert pytest.fuzzy_equal(y1.squeeze(), expected["y1"]) assert pytest.fuzzy_equal(z1.squeeze(), expected["z1"]) assert pytest.fuzzy_equal(x2.squeeze(), expected["x2"]) assert pytest.fuzzy_equal(y2.squeeze(), expected["y2"]) assert pytest.fuzzy_equal(z1.squeeze(), expected["z2"])
def test_kpm_multiple_indices(model): """KPM can take a vector of column indices and return the Green's function for all of them""" kpm = pb.greens.kpm(model) num_sites = model.system.num_sites i, j = num_sites // 2, num_sites // 4 energy = np.linspace(-0.3, 0.3, 10) broadening = 0.8 cols = [j, j + 1, j + 2] gs = kpm(i, cols, energy, broadening) assert len(gs) == len(cols) g = kpm(j, i, energy, broadening) assert pytest.fuzzy_equal(gs[0], g)
def test_wrapper_return(): """Make sure the boost python wrapper return type conversion is working""" @pb.hopping_energy_modifier def mul(energy): """Returning a non-contiguous view will force the wrapper to create a copy""" energy = np.concatenate([energy, energy]) energy *= 3 return energy[::2] lattice = pb.Lattice([1, 0]) lattice.add_sublattices(("A", [0, 0]), ("B", [0, 0])) lattice.add_one_hopping([0], "A", "B", 1.0) model = pb.Model(lattice, mul, pb.primitive(2)) assert pytest.fuzzy_equal(model.hamiltonian.data, [3, 3, 3, 3])
def test_make_lattice(): a, t = 1, 1 lat1 = pb.Lattice([a, 0], [0, a]) lat1.add_one_sublattice('s', (0, 0)) lat1.add_hoppings([(0, 1), 's', 's', t], [(1, 0), 's', 's', t]) lat1.min_neighbors = 2 lat2 = pb.make_lattice( vectors=[[a, 0], [0, a]], sublattices=[['s', (0, 0)]], hoppings=[[(0, 1), 's', 's', t], [(1, 0), 's', 's', t]], min_neighbors=2 ) assert pytest.fuzzy_equal(lat1, lat2)
def test_ndsweep(baseline): @pb.parallelize(v1=np.linspace(0, 0.1, 5), v2=np.linspace(-0.2, 0.2, 4)) def factory(v1, v2, energy=np.linspace(0, 0.1, 10)): model = pb.Model( graphene.monolayer(), graphene.hexagon_ac(side_width=15), pb.constant_potential(v1), pb.constant_potential(v2) ) kpm = pb.greens.kpm(model) return kpm.deferred_ldos(energy, broadening=0.15, position=[0, 0]) silence_parallel_output(factory) result = pb.parallel.ndsweep(factory) expected = baseline(result) assert pytest.fuzzy_equal(result, expected, rtol=1e-4, atol=1e-6)
def test_sweep(baseline, plot_if_fails): @pb.parallelize(v=np.linspace(0, 0.1, 10)) def factory(v, energy=np.linspace(0, 0.1, 10)): model = pb.Model( graphene.monolayer(), graphene.hexagon_ac(side_width=15), pb.constant_potential(v) ) kpm = pb.greens.kpm(model) return kpm.deferred_ldos(energy, broadening=0.15, position=[0, 0]) silence_parallel_output(factory) labels = dict(title="test sweep", x="V (eV)", y="E (eV)", data="LDOS") result = pb.parallel.sweep(factory, labels=labels) expected = baseline(result) plot_if_fails(result, expected, 'plot') assert pytest.fuzzy_equal(result, expected, rtol=1e-4, atol=1e-6)
def test_hopping_generator(): """Generated next-nearest hoppings should produce the same result as the builtin lattice""" from scipy.spatial import cKDTree @pb.hopping_generator("tnn_test", energy=graphene.t_nn) def next_nearest(x, y, z): pos = np.stack([x, y, z], axis=1) dmin = graphene.a * 0.95 dmax = graphene.a * 1.05 kdtree = cKDTree(pos) coo = kdtree.sparse_distance_matrix(kdtree, dmax).tocoo() idx = coo.data > dmin return coo.row[idx], coo.col[idx] @pb.onsite_energy_modifier def onsite_offset(energy): return energy + 3 * graphene.t_nn model = pb.Model(graphene.monolayer(), next_nearest, onsite_offset, graphene.hexagon_ac(1)) expected = pb.Model(graphene.monolayer(2), graphene.hexagon_ac(1)) assert pytest.fuzzy_equal(model.hamiltonian, expected.hamiltonian)
def test_expected(model, baseline, plot_if_fails): system = model.system expected = baseline(system) plot_if_fails(system, expected, 'plot') assert pytest.fuzzy_equal(system, expected, 1.e-4, 1.e-6)
def test_pickle_round_trip(model, tmpdir): file_name = str(tmpdir.join('file.npz')) pb.save(model.system, file_name) from_file = pb.load(file_name) assert pytest.fuzzy_equal(model.system, from_file)
def test_polygon(polygon, baseline, plot_if_fails): model = pb.Model(graphene.monolayer(), polygon) expected = baseline(model.system) plot_if_fails(model.system, expected, 'plot') plot_if_fails(polygon, polygon, 'plot') assert pytest.fuzzy_equal(model.system, expected, 1.e-4, 1.e-6)