def test_refine_square(): lattice_basis = make2D_lattice_basis([1,1], np.pi/2) ndivs = 6 grid_basis = make2D_lattice_basis([1/ndivs,1/ndivs], np.pi/2) offset = np.dot(inv(grid_basis), np.dot(lattice_basis, [-.5]*2)) grid = make_cell_points2D(lattice_basis, grid_basis, offset, grid_type="closed") args = {"lattice_basis": lattice_basis, "degree": 2, "prefactor":1, "nvalence_electrons": 3} free_2D = FreeElectron2D(**args) weights = np.ones(len(grid)) fermi_level, band_energy = rectangular_integration2D(free_2D, grid, weights) free_2D.fermi_level = fermi_level free_2D.band_energy = band_energy tess = square_tesselation(grid) all_squares, areas = refine_square(tess[2], free_2D, method="interpolate", ndivisions=2, derivative_tol=1e1) nsquares = int(np.prod(np.shape(all_squares))/2) all_pts = np.reshape(all_squares, (nsquares, 2)) unique_pts = make_unique(all_pts) all_squares2 = [[[1/3,0],[5/12, 0],[5/12, 1/12],[1/3, 1/12]], [[5/12, 0],[1/2, 0],[1/2, 1/12],[5/12, 1/12]], [[5/12, 1/12],[1/2, 1/12],[1/2, 1/6],[5/12, 1/6]], [[1/3, 1/12],[5/12, 1/12],[5/12, 1/6],[1/3, 1/6]]] unique_pts2 = [[1/3, 0],[5/12, 0],[1/2, 0],[1/3, 1/12],[5/12, 1/12], [1/2, 1/12],[1/3, 1/6],[5/12, 1/6],[1/2, 1/6]] assert (check_contained(unique_pts2, unique_pts) and check_contained(unique_pts, unique_pts2)) assert (check_contained(all_squares, all_squares2) and check_contained(all_squares2, all_squares))
def test_make_grid2(): # This unit test doesn't pass because the primitive translation vectors # changed when I updated the code (I think). grid_pts1 = [[0, 0, 0], [1, 1, 1], [0, 0, 2], [0, 2, 0], [0, 2, 2], [2, 0, 0], [0, 2, 2], [2, 0, 2], [2, 2, 0], [2, 2, 2], [1, 3, 3], [3, 1, 3], [3, 1, 1], [1, 1, 3], [1, 3, 1], [3, 1, 1]] grid_pts1 = np.asarray(grid_pts1) * 1. / 4 cell_centering = "prim" cell_const = 1. cell_const_list = [cell_const] * 3 cell_angles = [np.pi / 2] * 3 cell_vecs = make_ptvecs(cell_centering, cell_const_list, cell_angles) grid_centering = "body" grid_const = cell_const / 2 grid_const_list = [grid_const] * 3 grid_angles = [np.pi / 2] * 3 grid_vecs = make_ptvecs(grid_centering, grid_const_list, grid_angles) offset = np.asarray([0., 0., 0.]) grid = make_grid(cell_vecs, grid_vecs, offset, coords="lat") for g1 in grid_pts1: assert check_contained(g1, grid) lat_type_list = ["fcc"] lat_centering_list = ["face"] lat_const_list = [3 * np.pi] lat_consts_list = [[l] * 3 for l in lat_const_list] lat_angles = [np.pi / 2] * 3 offset_list = [[1.3, 1.1, 1.7]] r_list = [np.pi] for lat_centering in lat_centering_list: for lat_consts in lat_consts_list: lat_vecs = make_ptvecs(lat_centering, lat_consts, lat_angles) rlat_vecs = make_rptvecs(lat_vecs) for offset in offset_list: offset = np.asarray(offset) for r in r_list: total_grid = large_sphere_pts(lat_vecs, r, offset) grid = sphere_pts(lat_vecs, r, offset) contained = False for tg in total_grid: if np.dot(tg - offset, tg - offset) <= r: assert check_contained(tg, grid)
def test_square_tesselation(): ndivs = 2 grid_basis = make2D_lattice_basis([1/ndivs,1/ndivs], np.pi/2) lattice_basis = make2D_lattice_basis([1,1], np.pi/2) offset = [0,0] grid = make_cell_points2D(lattice_basis, grid_basis, offset, grid_type="closed") square_tess = square_tesselation(grid) subsquares_list = [[[0, 0], [.5, 0], [.5, .5], [0, .5]], [[0, .5], [.5, .5], [.5, 1], [0, 1]], [[.5, 0], [1, 0], [1, .5], [.5, .5]], [[.5, .5], [1, .5], [1, 1], [.5, 1]]] assert (check_contained(square_tess, subsquares_list) and check_contained(subsquares_list, square_tess))
def test_get_circle_pts(): lattice_constants = [1]*2 lattice_angle = np.pi/2 lattice_basis = make2D_lattice_basis(lattice_constants, lattice_angle) radius = 2 pts = [ [0, 0], [1, 0], [0, 1], [1, 1], [-1, 0], [0, -1], [-1, -1], [-1, 1], [1, -1]] circle_pts = get_circle_pts(lattice_basis, radius) assert check_contained(pts, circle_pts) assert len(pts) == len(circle_pts)
def get_unique_planes(BZ, rtol=1e-5, atol=1e-8): """Find the unique planes that form the boundaries of a Brillouin zone. Args: BZ (scipy.spatial.ConvexHull): a convex hull object Returns: unique_plane (numpy.ndarray): an array of unique planes in general form. """ unique_planes = [] for plane in BZ.equations: if not check_contained([plane], unique_planes, rtol=rtol, atol=atol): unique_planes.append(plane) return np.array(unique_planes)
def test_make_cell_points(): """Verify the grid satisfies various properties, such as verifying the neighbors of each point are withing the grid as long as the neighbors lie within the unit cell. Also verify none of the points lie outside the unit cell. """ # At the moment it only tests the cubic lattices. grid_center_list = ["prim", "face"] grid_constants = np.array([1. / 2, 1. / 4]) * 2 * np.sqrt(2) grid_consts_list = [[m] * 3 for m in grid_constants] grid_angles = [np.pi / 2] * 3 cell_center_list = ["prim", "body"] cell_constants = [2 * np.sqrt(2)] cell_consts_list = [[c] * 3 for c in cell_constants] cell_angles = [np.pi / 2] * 3 offsets = [[0., 0., 0.], [1. / 2, 1. / 2, 1. / 2]] # for grid_constant in grid_constants: for grid_consts in grid_consts_list: for grid_center in grid_center_list: grid_vectors = make_ptvecs(grid_center, grid_consts, grid_angles) grid_lengths = [np.linalg.norm(lv) for lv in grid_vectors] for cell_consts in cell_consts_list: for cell_center in cell_center_list: cell_vectors = make_ptvecs(cell_center, cell_consts, cell_angles) cell_lengths = [np.linalg.norm(cv) for cv in cell_vectors] for offset in offsets: grid = make_cell_points(cell_vectors, grid_vectors, offset) grid2, null_grid = make_large_grid( cell_vectors, grid_vectors, offset) # Verify all the points in the cell for the large grid # are contained in grid. assert check_contained(grid, grid2)