Question

I’m trying to construct a nearest neighbor list in python that stores the nearest neighbors of a node in a finite 3d hexagonal-closest packing (HCP) lattice. I’ve done this already with a 2d square lattice defining the structure like so. I don’t want coordinates, but just a quick way to create a nearest neighbor list for an HCP out of a list of integers. Below is the sample code of how I did this task with a square lattice.

N = int #number of nodes
L = side # a 32x32 graph, L would be 32

for i in range(N):

    nearNeighbor[i][0] = (i + 1 ) % N
    nearNeighbor[i][1] = (i + (N - 1)) % N
    nearNeighbor[i][2] = (i + L) % N
    nearNeighbor[i][3] = (i + N - L) % N

    if (i-L < 0):
         nearNeighbor[i][3] = -2
    if (i+L >= N):
         nearNeighbor[i][2] = -2
    if (i%L) == 0:
         nearNeighbor[i][1] = -2     
    if ((i+1)%L) == 0:
         nearN[eighbori][0] = -2

That’s it. Now an HCP lattice, when visualized, resembles a giant cube of spheres closely packed together. Each node should have at most 12 nearest neighbors and they should come out to make something like a cube. I guess largely I want to know how to use integers and modular arithmetic to represent the HCP lattice like I did with the square lattice. Can you help me stack?

Answer 1

The answer to this question depends on how one chooses to truncate the HCP lattice and index it. One choice is

With this choice, the following code will return a list of neighbors of a given site.

def neighbors(i, W, H, D):
  A = W * H

  plane = i / A
  plane_index = i % A
  row = plane_index / W
  col = plane_index % W

  r = -1 if row % 2 else 1   # (-1)**row
  p = -1 if plane % 2 else 1 # (-1)**plane

  nbors = []

  # first include neighbors in same plane
  if col != W-1: nbors.append(i+1)
  if col != 0:   nbors.append(i-1)
  if row != H-1: nbors.append(i+W)
  if row != 0:   nbors.append(i-W)
  if (col != 0 or r > 0) and (col != W-1 or r < 0):
    if row != H-1: nbors.append(i+W+r)
    if row != 0:   nbors.append(i-W+r)

  # now add neighbors from other planes
  if plane != D-1: nbors.append(i+A)
  if plane != 0:   nbors.append(i-A)

  if (col != 0 or p < 0) and (col != W-1 or p > 0):
    if plane != D-1: nbors.append(i+A-p)
    if plane != 0:   nbors.append(i-A-p)

  if ((col != W - 1 or p > 0 or r < 0) and
      (col != 0 or p < 0 or r > 0) and
      (row != H-1 or p < 0) and
      (row != 0 or p > 0)):
    if plane != D-1:
      nbors.append(i + A + p*W + (r-p)/2) #10
    if plane != 0:
      nbors.append(i - A + p*W + (r-p)/2) #11

  return nbors

To make sure I got the logic correct, I used the following test while writing the above function

def test_neighbors():
  n = lambda i: set(neighbors(i, 5, 5, 5))

  # test bottom layer
  assert n(0) == set([1,5,6,25,30])
  assert n(2) == set([1,3,7,8,26,27,32])
  assert n(4) == set([3,9,28,29,34])
  assert n(5) == set([0,6,10,30])
  assert n(9) == set([3,4,8,13,14,33,34,38])
  assert n(20) == set([15,16,21,45])
  assert n(21) == set([16,17,20,22,45,46])
  assert n(24) == set([19,23,48,49])

  # test second layer
  assert n(25) == set([0,1,26,30,31,50,51])
  assert n(34) == set([4,9,28,29,33,38,39,54,59])
  assert n(36) == set([7,11,12,31,32,35,37,41,42,57,61,62])
  assert n(49) == set([24,44,48,74])

Note that the test doesn’t cover all of the unique types of sites, so, there may still be a corner case somewhere that is wrong.